Change of STANDALONE run types in Preprocessor + retrieval and use of two more FEE...
[u/mrichter/AliRoot.git] / 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 }