VZERO/AliVZERORawStream.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 ///////////////////////////////////////////////////////////////////////////////
  17 ///
  18 /// This is a class for reading the VZERO DDL raw data
  19 /// The format of the raw data corresponds to the one
  20 /// implemented in AliVZEROBuffer class.
  21 ///
  22 ///////////////////////////////////////////////////////////////////////////////
  23
  24 #include "AliVZERORawStream.h"
  25 #include "AliRawReader.h"
  26 #include "AliLog.h"
  27 #include "AliDAQ.h"
  28
  29 ClassImp(AliVZERORawStream)
  30
  31 //_____________________________________________________________________________
  32 AliVZERORawStream::AliVZERORawStream(AliRawReader* rawReader) :
  33   fTrigger(0),
  34   fTriggerMask(0),
  35   fPosition(-1),
  36   fRawReader(rawReader),
  37   fData(NULL)
  38 {
  39   // create an object to read VZERO raw data
  40   //
  41   // select the raw data corresponding to
  42   // the VZERO detector id
  43   fRawReader->Reset();
  44   AliDebug(1,Form("Selecting raw data for detector %d",AliDAQ::DetectorID("VZERO")));
  45   fRawReader->Select("VZERO");
  46
  47   // Initalize the containers
  48   for(Int_t i = 0; i < kNChannels; i++) {
  49     fTime[i] = fWidth[i] = 0.;
  50     for(Int_t j = 0; j < kNEvOfInt; j++) {
  51       fADC[i][j] = 0.;
  52       fIsInt[i][j] = fIsBB[i][j] = fIsBG[i][j] = kFALSE;
  53     }
  54     fBBScalers[i] = fBGScalers[i] = 0;
  55     for(Int_t j = 0; j < kNBunches; j++) {
  56       fChargeMB[i][j] = 0;
  57       fIsIntMB[i][j] = fIsBBMB[i][j] = fIsBGMB[i][j] = kFALSE;
  58     }
  59   }
  60   for(Int_t i = 0; i < kNScalers; i++) fScalers[i] = 0;
  61   for(Int_t i = 0; i < kNBunches; i++) fBunchNumbers[i] = 0;
  62 }
  63
  64 //_____________________________________________________________________________
  65 AliVZERORawStream::~AliVZERORawStream()
  66 {
  67   // destructor
  68 }
  69
  70 //_____________________________________________________________________________
  71 void AliVZERORawStream::Reset()
  72 {
  73   // reset raw stream params
  74
  75   // Reinitalize the containers
  76   for(Int_t i = 0; i < kNChannels; i++) {
  77     fTime[i] = fWidth[i] = 0.;
  78     for(Int_t j = 0; j < kNEvOfInt; j++) {
  79       fADC[i][j] = 0.;
  80       fIsInt[i][j] = fIsBB[i][j] = fIsBG[i][j] = kFALSE;
  81     }
  82     fBBScalers[i] = fBGScalers[i] = 0;
  83     for(Int_t j = 0; j < kNBunches; j++) {
  84       fChargeMB[i][j] = 0;
  85       fIsIntMB[i][j] = fIsBBMB[i][j] = fIsBGMB[i][j] = kFALSE;
  86     }
  87   }
  88   for(Int_t i = 0; i < kNScalers; i++) fScalers[i] = 0;
  89   for(Int_t i = 0; i < kNBunches; i++) fBunchNumbers[i] = 0;
  90
  91   fTrigger = fTriggerMask = 0;
  92   fPosition = -1;
  93   fData = NULL;
  94
  95   if (fRawReader) fRawReader->Reset();
  96 }
  97
  98 //_____________________________________________________________________________
  99 Bool_t AliVZERORawStream::Next()
 100 {
 101   // read next digit from the VZERO raw data stream
 102   // return kFALSE in case of error or no digits left
 103
 104   if (fPosition >= 0) return kFALSE;
 105
 106   if (!fRawReader->ReadNextData(fData)) return kFALSE;
 107   if (fRawReader->GetDataSize() == 0) return kFALSE;
 108
 109   if (fRawReader->GetDataSize() != 5936) {
 110      fRawReader->AddFatalErrorLog(kRawDataSizeErr,Form("size %d != 5936",fRawReader->GetDataSize()));
 111      AliWarning(Form("Wrong VZERO raw data size: %d, expected 5936 bytes!",fRawReader->GetDataSize()));
 112      return kFALSE;
 113   }
 114
 115   fPosition = 0;
 116
 117   fTrigger = GetNextWord() & 0xffff;
 118   fTriggerMask = GetNextWord() & 0xffff;
 119
 120   for(Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
 121      fScalers[iScaler] = GetNextWord();
 122
 123   for(Int_t iBunch = 0; iBunch < kNBunches; iBunch++)
 124      fBunchNumbers[iBunch] = GetNextWord();
 125
 126   for (Int_t  iCIU = 0; iCIU < 8; iCIU++) {
 127
 128   // decoding of one Channel Interface Unit numbered iCIU - there are 8 channels per CIU (and 8 CIUs) :
 129
 130     for (Int_t iChannel_Offset = iCIU*8; iChannel_Offset < (iCIU*8)+8; iChannel_Offset=iChannel_Offset+4) {
 131       for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
 132         for(Int_t iEvOfInt = 0; iEvOfInt < kNEvOfInt; iEvOfInt++) {
 133           UShort_t data = GetNextShort();
 134           fADC[iChannel][iEvOfInt] = Float_t (data & 0x3ff);
 135           fIsInt[iChannel][iEvOfInt] = (data >> 10) & 0x1;
 136         }
 137       }
 138       for(Int_t iEvOfInt = 0; iEvOfInt < kNEvOfInt; iEvOfInt=iEvOfInt+2) {
 139         UShort_t data = GetNextShort();
 140         for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
 141           fIsBB[iChannel][iEvOfInt] = (data >>  2*(iChannel-iChannel_Offset)) & 0x1;
 142           fIsBG[iChannel][iEvOfInt] = (data >> (2*(iChannel-iChannel_Offset)+1)) & 0x1;
 143           if(iEvOfInt < (kNEvOfInt - 1)) {
 144              fIsBB[iChannel][iEvOfInt+1] = (data >> (8+ 2*(iChannel-iChannel_Offset))) & 0x1;
 145              fIsBG[iChannel][iEvOfInt+1] = (data >> (8+ 2*(iChannel-iChannel_Offset)+1)) & 0x1;
 146           }
 147         }
 148       }
 149
 150       GetNextShort();
 151
 152       for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
 153         for(Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
 154           UShort_t data = GetNextShort();
 155           fChargeMB[iChannel][iBunch] = data & 0x3ff;
 156           fIsIntMB[iChannel][iBunch] = (data >> 10) & 0x1;
 157         }
 158       }
 159
 160       for(Int_t iBunch = 0; iBunch < kNBunches; iBunch=iBunch+2) {
 161         UShort_t data = GetNextShort();
 162         for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
 163           fIsBBMB[iChannel][iBunch] = (data >>  2*iBunch) & 0x1;
 164           fIsBGMB[iChannel][iBunch] = (data >> (2*iBunch+1)) & 0x1;
 165           if(iBunch < (kNBunches - 1)) {
 166              fIsBBMB[iChannel][iBunch+1] = (data >> (8+2*iBunch)) & 0x1;
 167              fIsBGMB[iChannel][iBunch+1] = (data >> (8+2*iBunch+1)) & 0x1;
 168           }
 169         }
 170       }
 171
 172       GetNextShort();
 173
 174       for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
 175         fBBScalers[iChannel] = ((ULong64_t)GetNextWord()) << 32;
 176         fBBScalers[iChannel] |= GetNextWord();
 177         fBGScalers[iChannel] = ((ULong64_t)GetNextWord()) << 32;
 178         fBGScalers[iChannel] |= GetNextWord();
 179       }
 180
 181     }
 182
 183 //    for(Int_t iChannel = iCIU*8; iChannel < (iCIU*8) + 8; iChannel++) {
 184 //    In fact times are stored the other way around in raw data...
 185       for(Int_t iChannel = (iCIU*8) + 7; iChannel >= iCIU*8; iChannel--) {
 186         UInt_t time = GetNextWord();
 187         Float_t coarse1  = 25. * ((time >> 8) & 0xf );
 188         Float_t coarse2  = 25. / 8. * ((time >> 5) & 0x7 );
 189         Float_t fine     = 25. / 256. * (time & 0x1f);
 190         // fTime[iChannel] = time & 0xfff;
 191         fTime[iChannel]  = coarse1 + coarse2 + fine;
 192         fWidth[iChannel] = 0.4 * ( (time >> 12) & 0x7f);   // HPTDC used in pairing mode
 193     }
 194
 195     // End of decoding of one CIU card
 196     // printf("Number of bytes used at end of reading CIU card number %d %d \n\n", iCIU+1, fPosition);
 197
 198   } // end of decoding the eight CIUs
 199
 200   return kTRUE;
 201 }
 202
 203 //_____________________________________________________________________________
 204 UInt_t AliVZERORawStream::GetNextWord()
 205 {
 206   // This method returns the next 32 bit word
 207   // inside the raw data payload.
 208   // The method is supposed to be endian (platform)
 209   // independent.
 210   if (!fData || fPosition < 0) AliFatal("Raw data payload buffer is not yet initialized !");
 211
 212   UInt_t word = 0;
 213   word |= fData[fPosition++];
 214   word |= fData[fPosition++] << 8;
 215   word |= fData[fPosition++] << 16;
 216   word |= fData[fPosition++] << 24;
 217
 218   return word;
 219 }
 220
 221 //_____________________________________________________________________________
 222 UShort_t AliVZERORawStream::GetNextShort()
 223 {
 224   // This method returns the next 16 bit word
 225   // inside the raw data payload.
 226   // The method is supposed to be endian (platform)
 227   // independent.
 228   if (!fData || fPosition < 0) AliFatal("Raw data payload buffer is not yet initialized !");
 229
 230   UShort_t word = 0;
 231   word |= fData[fPosition++];
 232   word |= fData[fPosition++] << 8;
 233
 234   return word;
 235 }