Adding the centrality-trigger charge sums. Adding also the corresponding histogram...
[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 #include "AliVZEROCalibData.h"
29 #include "AliVZEROTriggerData.h"
30 ClassImp(AliVZERORawStream)
31
32 //_____________________________________________________________________________
33 AliVZERORawStream::AliVZERORawStream(AliRawReader* rawReader) :
34   fTrigger(0),
35   fTriggerMask(0),
36   fPosition(-1),
37   fRawReader(rawReader),
38   fData(NULL)
39 {
40   // create an object to read VZERO raw data
41   //
42   // select the raw data corresponding to
43   // the VZERO detector id
44   fRawReader->Reset();
45   AliDebug(1,Form("Selecting raw data for detector %d",AliDAQ::DetectorID("VZERO")));
46   fRawReader->Select("VZERO");
47
48   // Initalize the containers
49   for(Int_t i = 0; i < kNChannels; i++) {
50     fTime[i] = fWidth[i] = 0;
51     for(Int_t j = 0; j < kNEvOfInt; j++) {
52       fADC[i][j] = 0;
53       fIsInt[i][j] = fIsBB[i][j] = fIsBG[i][j] = kFALSE;
54     }
55     fBBScalers[i] = fBGScalers[i] = 0;
56     for(Int_t j = 0; j < kNBunches; j++) {
57       fChargeMB[i][j] = 0;
58       fIsIntMB[i][j] = fIsBBMB[i][j] = fIsBGMB[i][j] = kFALSE;
59     }
60   }
61   for(Int_t i = 0; i < kNScalers; i++) fScalers[i] = 0;
62   for(Int_t i = 0; i < kNBunches; i++) fBunchNumbers[i] = 0;
63 }
64
65 //_____________________________________________________________________________
66 AliVZERORawStream::~AliVZERORawStream()
67 {
68   // destructor
69 }
70
71 //_____________________________________________________________________________
72 void AliVZERORawStream::Reset()
73 {
74   // reset raw stream params
75
76   // Reinitalize the containers
77   for(Int_t i = 0; i < kNChannels; i++) {
78     fTime[i] = fWidth[i] = 0;
79     for(Int_t j = 0; j < kNEvOfInt; j++) {
80       fADC[i][j] = 0;
81       fIsInt[i][j] = fIsBB[i][j] = fIsBG[i][j] = kFALSE;
82     }
83     fBBScalers[i] = fBGScalers[i] = 0;
84     for(Int_t j = 0; j < kNBunches; j++) {
85       fChargeMB[i][j] = 0;
86       fIsIntMB[i][j] = fIsBBMB[i][j] = fIsBGMB[i][j] = kFALSE;
87     }
88   }
89   for(Int_t i = 0; i < kNScalers; i++) fScalers[i] = 0;
90   for(Int_t i = 0; i < kNBunches; i++) fBunchNumbers[i] = 0;
91
92   fTrigger = fTriggerMask = 0;
93   fPosition = -1;
94   fData = NULL;
95
96   if (fRawReader) fRawReader->Reset();
97 }
98
99 //_____________________________________________________________________________
100 Bool_t AliVZERORawStream::Next()
101 {
102   // read next digit from the VZERO raw data stream
103   // return kFALSE in case of error or no digits left
104
105   if (fPosition >= 0) return kFALSE;
106
107   if (!fRawReader->ReadNextData(fData)) return kFALSE;
108   if (fRawReader->GetDataSize() == 0) return kFALSE;
109      
110   if (fRawReader->GetDataSize() != 5936) {
111      fRawReader->AddFatalErrorLog(kRawDataSizeErr,Form("size %d != 5936",fRawReader->GetDataSize()));
112      AliWarning(Form("Wrong VZERO raw data size: %d, expected 5936 bytes!",fRawReader->GetDataSize()));
113      return kFALSE;
114   }
115
116   fPosition = 0;
117
118   fTrigger = GetNextWord() & 0xffff;
119   fTriggerMask = GetNextWord() & 0xffff;
120
121   for(Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
122      fScalers[iScaler] = GetNextWord();
123
124   for(Int_t iBunch = 0; iBunch < kNBunches; iBunch++)
125      fBunchNumbers[iBunch] = GetNextWord();
126  
127   for (Int_t  iCIU = 0; iCIU < 8; iCIU++) { 
128  
129   // decoding of one Channel Interface Unit numbered iCIU - there are 8 channels per CIU (and 8 CIUs) :
130   
131     for (Int_t iChannel_Offset = iCIU*8; iChannel_Offset < (iCIU*8)+8; iChannel_Offset=iChannel_Offset+4) { 
132       for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
133         for(Int_t iEvOfInt = 0; iEvOfInt < kNEvOfInt; iEvOfInt++) {
134           UShort_t data = GetNextShort();
135           fADC[iChannel][iEvOfInt] = data & 0x3ff;
136           fIsInt[iChannel][iEvOfInt] = (data >> 10) & 0x1;
137         }
138       }
139       for(Int_t iEvOfInt = 0; iEvOfInt < kNEvOfInt; iEvOfInt=iEvOfInt+2) {
140         UShort_t data = GetNextShort();
141         for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {          
142           fIsBB[iChannel][iEvOfInt] = (data >>  2*(iChannel-iChannel_Offset)) & 0x1;
143           fIsBG[iChannel][iEvOfInt] = (data >> (2*(iChannel-iChannel_Offset)+1)) & 0x1; 
144           if(iEvOfInt < (kNEvOfInt - 1)) {      
145              fIsBB[iChannel][iEvOfInt+1] = (data >> (8+ 2*(iChannel-iChannel_Offset))) & 0x1;
146              fIsBG[iChannel][iEvOfInt+1] = (data >> (8+ 2*(iChannel-iChannel_Offset)+1)) & 0x1;
147           }
148         }
149       }
150
151       GetNextShort();
152
153       for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
154         for(Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
155           UShort_t data = GetNextShort();
156           fChargeMB[iChannel][iBunch] = data & 0x3ff;
157           fIsIntMB[iChannel][iBunch] = (data >> 10) & 0x1;
158         } 
159       }
160    
161       for(Int_t iBunch = 0; iBunch < kNBunches; iBunch=iBunch+2) {
162         UShort_t data = GetNextShort();
163         for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {  
164           fIsBBMB[iChannel][iBunch] = (data >>  2*iBunch) & 0x1;
165           fIsBGMB[iChannel][iBunch] = (data >> (2*iBunch+1)) & 0x1;
166           if(iBunch < (kNBunches - 1)) {
167              fIsBBMB[iChannel][iBunch+1] = (data >> (8+2*iBunch)) & 0x1;
168              fIsBGMB[iChannel][iBunch+1] = (data >> (8+2*iBunch+1)) & 0x1;
169           }       
170         }
171       }
172   
173       GetNextShort();
174    
175       for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
176         fBBScalers[iChannel] = ((ULong64_t)GetNextWord()) << 32;
177         fBBScalers[iChannel] |= GetNextWord();
178         fBGScalers[iChannel] = ((ULong64_t)GetNextWord()) << 32;
179         fBGScalers[iChannel] |= GetNextWord();
180       }
181
182     } 
183
184     for(Int_t iChannel = (iCIU*8) + 7; iChannel >= iCIU*8; iChannel--) { 
185       UInt_t time = GetNextWord();
186       fTime[iChannel]  = time & 0xfff;
187       fWidth[iChannel] = ((time >> 12) & 0x7f); // HPTDC used in pairing mode
188     }
189     
190     // End of decoding of one CIU card
191     // printf("Number of bytes used at end of reading CIU card number %d %d \n\n", iCIU+1, fPosition); 
192     
193   } // end of decoding the eight CIUs
194     
195   return kTRUE;
196 }
197
198 //_____________________________________________________________________________
199 UInt_t AliVZERORawStream::GetNextWord()
200 {
201   // This method returns the next 32 bit word
202   // inside the raw data payload.
203   // The method is supposed to be endian (platform)
204   // independent.
205   if (!fData || fPosition < 0) AliFatal("Raw data payload buffer is not yet initialized !");
206
207   UInt_t word = 0;
208   word |= fData[fPosition++];
209   word |= fData[fPosition++] << 8;
210   word |= fData[fPosition++] << 16;
211   word |= fData[fPosition++] << 24;
212
213   return word;
214 }
215
216 //_____________________________________________________________________________
217 UShort_t AliVZERORawStream::GetNextShort()
218 {
219   // This method returns the next 16 bit word
220   // inside the raw data payload.
221   // The method is supposed to be endian (platform)
222   // independent.
223   if (!fData || fPosition < 0) AliFatal("Raw data payload buffer is not yet initialized !");
224
225   UShort_t word = 0;
226   word |= fData[fPosition++];
227   word |= fData[fPosition++] << 8;
228
229   return word;
230 }
231
232 //_____________________________________________________________________________
233 void AliVZERORawStream::CalculateChargeForCentrTriggers(AliVZEROTriggerData *triggerData,
234                                                         UShort_t &chargeA, UShort_t &chargeC) const
235 {
236   // Use the raw-data payload
237   // in order to calculate the total
238   // charge (which is used in the
239   // centrality triggers) on each side of V0
240   if (!triggerData) {
241     AliFatal("Trigger configuration data is not provided. Exiting...");
242     return;
243   }
244   chargeA = chargeC = 0;
245   for(Int_t iChannel=0; iChannel<64; iChannel++) {
246     Int_t offlineCh = GetOfflineChannel(iChannel);
247     Int_t board = AliVZEROCalibData::GetBoardNumber(offlineCh);
248     Int_t feeChannel = AliVZEROCalibData::GetFEEChannelNumber(offlineCh);
249     if (triggerData->GetEnableCharge(board,feeChannel)) {
250       Bool_t integ10 = GetIntegratorFlag(iChannel,10);
251       UShort_t ch10 = (UShort_t)GetPedestal(iChannel,10);
252       UShort_t trPed = (integ10 == kFALSE) ? triggerData->GetPedestal(0,board,feeChannel) : triggerData->GetPedestal(1,board,feeChannel);
253       UShort_t trPedCut = (integ10 == kFALSE) ? triggerData->GetPedestalCut(0,board,feeChannel) : triggerData->GetPedestalCut(1,board,feeChannel);
254       if (!triggerData->GetPedestalSubtraction(board)) trPed = trPedCut = 0;
255       if (ch10 > trPedCut) {
256         if (offlineCh < 32) {
257           chargeC += (ch10 - trPed);
258         }
259         else {
260           chargeA += (ch10 - trPed);
261         }
262       }
263     }
264   }
265 }