Update master to aliroot
[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloDigitMaker.cxx
1 // $Id$
2
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        * 
5  * All rights reserved.                                                   *
6  *                                                                        *
7  * Primary Authors: Oystein Djuvsland                                     *
8  *                                                                        *
9  * Permission to use, copy, modify and distribute this software and its   *
10  * documentation strictly for non-commercial purposes is hereby granted   *
11  * without fee, provided that the above copyright notice appears in all   *
12  * copies and that both the copyright notice and this permission notice   *
13  * appear in the supporting documentation. The authors make no claims     *
14  * about the suitability of this software for any purpose. It is          * 
15  * provided "as is" without express or implied warranty.                  *
16  **************************************************************************/
17  /** 
18  * @file   AliHLTCaloDigitMaker.cxx
19  * @author Oystein Djuvsland
20  * @date 
21  * @brief  Digit maker for CALO HLT  
22  */
23       
24
25 // see header file for class documentation
26 // or
27 // refer to README to build package
28 // or
29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
30
31 #include "AliHLTCaloDigitMaker.h"
32 #include "AliHLTCaloConstantsHandler.h"
33 #include "AliHLTCaloMapper.h"
34 #include "AliHLTCaloChannelDataStruct.h"
35 #include "AliHLTCaloChannelDataHeaderStruct.h"
36 #include "AliHLTCaloDigitDataStruct.h"
37 #include "AliHLTCaloCoordinate.h"
38 #include "AliHLTCaloSharedMemoryInterfacev2.h" // added by PTH
39 //#include "AliPHOSEMCAGeometry.h"
40 #include "TH2F.h"
41 #include "AliHLTCaloConstants.h"
42 #include "AliHLTLogging.h"
43
44 ClassImp(AliHLTCaloDigitMaker);
45
46 //using namespace CaloHLTConst;
47
48 AliHLTCaloDigitMaker::AliHLTCaloDigitMaker(TString det) :
49   AliHLTCaloConstantsHandler(det),
50   AliHLTLogging(),
51   fShmPtr(0),
52   fDigitStructPtr(0),
53   fDigitCount(0),
54   fMapperPtr(0),
55   fHighGainFactors(0),
56   fLowGainFactors(0),
57   fBadChannelMask(0),
58   fChannelBook(0),
59   fMaxEnergy(900),
60   fMinTime(0.0),
61   fMaxTime(1008.0)
62 {
63   // See header file for documentation
64
65   fShmPtr = new AliHLTCaloSharedMemoryInterfacev2(det);
66
67   fHighGainFactors = new Float_t*[fCaloConstants->GetNXCOLUMNSMOD()];
68   fLowGainFactors = new Float_t*[fCaloConstants->GetNXCOLUMNSMOD()];
69   
70   fBadChannelMask = new Bool_t**[fCaloConstants->GetNXCOLUMNSMOD()];
71   
72   fChannelBook= new AliHLTCaloDigitDataStruct**[fCaloConstants->GetNXCOLUMNSMOD()];
73   
74   for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)
75     {
76       fHighGainFactors[x] = new Float_t[fCaloConstants->GetNZROWSMOD()];
77       fLowGainFactors[x] = new Float_t[fCaloConstants->GetNZROWSMOD()];
78
79       fBadChannelMask[x] = new Bool_t*[fCaloConstants->GetNZROWSMOD()];
80
81       fChannelBook[x] = new AliHLTCaloDigitDataStruct*[fCaloConstants->GetNZROWSMOD()];
82
83       for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)
84         {
85
86           fHighGainFactors[x][z] = 0.0153;
87           fLowGainFactors[x][z] = 0.245;
88          
89           fBadChannelMask[x][z] = new Bool_t[fCaloConstants->GetNGAINS()];
90           fBadChannelMask[x][z][fCaloConstants->GetHIGHGAIN()] = false;
91           fBadChannelMask[x][z][fCaloConstants->GetLOWGAIN()] = false; 
92           
93           fChannelBook[x][z] = 0;
94           
95         }
96     }     
97 }
98
99 AliHLTCaloDigitMaker::~AliHLTCaloDigitMaker() 
100 {
101   //See header file for documentation
102   delete [] fHighGainFactors;
103   delete [] fLowGainFactors;
104   delete [] fBadChannelMask;  
105   delete [] fChannelBook;
106   delete fShmPtr;
107
108 }
109
110 Int_t
111 AliHLTCaloDigitMaker::MakeDigits(AliHLTCaloChannelDataHeaderStruct* channelDataHeader, AliHLTUInt32_t availableSize)
112 {
113   //See header file for documentation
114   
115   Reset();
116
117   UInt_t totSize = sizeof(AliHLTCaloDigitDataStruct);
118   
119 //   Int_t xMod = -1;
120 //   Int_t zMod = -1;
121   
122
123   AliHLTCaloCoordinate coord;
124   
125   
126   AliHLTCaloChannelDataStruct* currentchannel = 0;
127   
128   fShmPtr->SetMemory(channelDataHeader);
129   currentchannel = fShmPtr->NextChannel();
130
131   while(currentchannel != 0)
132     {
133       if(availableSize < totSize) return -1;
134
135       fMapperPtr->ChannelId2Coordinate(currentchannel->fChannelID, coord);
136       
137       //      fMapperPtr->GetLocalCoord(currentchannel->fChannelID, locCoord);
138       if(UseDigit(coord, currentchannel))
139       {
140         AddDigit(currentchannel, coord);
141         //      j++;          
142         totSize += sizeof(AliHLTCaloDigitDataStruct);
143       }
144       currentchannel = fShmPtr->NextChannel(); // Get the next channel
145     }
146 //       if(currentchannel)
147 //      {
148 //        fMapperPtr->GetLocalCoord(currentchannel->fChannelID, locCoord);
149 //        if(UseDigit(coord1, currentchannel))
150 //          {
151 //            AddDigit(currentchannel, coord1, locCoord);
152 //            j++;            
153 //            totSize += sizeof(AliHLTCaloDigitDataStruct);
154 //          }
155 //        currentchannel = fShmPtr->NextChannel(); // Get the next channel
156 //      }
157 //     }
158    
159 //   fDigitCount += j;
160    return fDigitCount; 
161 }
162
163 void 
164 AliHLTCaloDigitMaker::SetGlobalHighGainFactor(Float_t factor)
165 {
166   //See header file for documentation
167   for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)
168     {
169       for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)
170         {
171           fHighGainFactors[x][z] = factor;
172         }
173     }
174 }
175
176
177 void
178 AliHLTCaloDigitMaker::SetGlobalLowGainFactor(Float_t factor)
179 {
180   //See header file for documentation
181   for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)
182     {
183       for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)
184         {
185           fLowGainFactors[x][z] = factor;
186         }
187     }
188 }
189
190
191 void
192 AliHLTCaloDigitMaker::SetBadChannelMask(TH2F* badChannelHGHist, TH2F* badChannelLGHist, Float_t qCut)
193 {
194  for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)
195     {
196       for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)
197         {
198           if(badChannelHGHist->GetBinContent(x, z) < qCut && badChannelHGHist->GetBinContent(x, z) > 0)
199             {
200               fBadChannelMask[x][z][fCaloConstants->GetHIGHGAIN()] = true;
201             }
202           else
203             {
204               fBadChannelMask[x][z][fCaloConstants->GetHIGHGAIN()] = false;
205             }
206           if(badChannelLGHist->GetBinContent(x, z) < qCut && badChannelLGHist->GetBinContent(x, z) > 0)
207             {
208               fBadChannelMask[x][z][fCaloConstants->GetLOWGAIN()] = false;
209             }
210           else
211             {
212               fBadChannelMask[x][z][fCaloConstants->GetLOWGAIN()] = false;
213             }
214         }
215     }
216 }
217
218 void
219 AliHLTCaloDigitMaker::Reset()
220 {
221   fDigitCount = 0;
222   for(int x = 0; x < fCaloConstants->GetNXCOLUMNSMOD(); x++)
223     {
224       for(int z = 0; z < fCaloConstants->GetNZROWSMOD(); z++)
225         {
226           fChannelBook[x][z] = 0;
227         }
228     }     
229
230 }
231
232
233 void AliHLTCaloDigitMaker::AddDigit(AliHLTCaloChannelDataStruct* channelData, AliHLTCaloCoordinate &coord)
234 {
235
236   // Some book keeping of the pointers
237   AliHLTCaloDigitDataStruct *tmpDigit = fDigitStructPtr + 1;
238
239   // Check if we already have a digit in this position, and correct the book keeping correspondently
240   if(fChannelBook[coord.fX][coord.fZ]) 
241     {
242       tmpDigit = fDigitStructPtr;
243       fDigitStructPtr = fChannelBook[coord.fX][coord.fZ];
244       fDigitCount--;
245       //      printf("Going to overwrite digit: x = %d, z = %d, gain = %d, energy = %f\n", fDigitStructPtr->fX, fDigitStructPtr->fZ, fDigitStructPtr->fGain, fDigitStructPtr->fEnergy);
246     }
247   
248   fChannelBook[coord.fX][coord.fZ] = fDigitStructPtr;
249  
250   fDigitStructPtr->fX = coord.fX;
251   fDigitStructPtr->fZ = coord.fZ;
252   fDigitStructPtr->fGain = coord.fGain;
253   fDigitStructPtr->fOverflow = false;
254   fDigitStructPtr->fAssociatedCluster = -1;
255   
256   fDigitStructPtr->fID = fDigitStructPtr->fZ * fCaloConstants->GetNXCOLUMNSMOD() + fDigitStructPtr->fX;
257   
258   if(coord.fGain == fCaloConstants->GetHIGHGAIN() )
259     {
260       fDigitStructPtr->fEnergy = channelData->fEnergy*fHighGainFactors[coord.fX][coord.fZ];
261       fDigitStructPtr->fHgPresent = true;
262       if(channelData->fEnergy >= fMaxEnergy)
263         {
264           fDigitStructPtr->fOverflow = true;
265         }
266       
267       HLTDebug("HG channel (x = %d, z = %d) with amplitude: %f --> Digit with energy: %f \n", 
268                coord.fX, coord.fZ, channelData->fEnergy, fDigitStructPtr->fEnergy);
269     }
270   else
271     {
272       fDigitStructPtr->fEnergy = channelData->fEnergy*fLowGainFactors[coord.fX][coord.fZ];
273       if(channelData->fEnergy >= fMaxEnergy)
274         {
275           fDigitStructPtr->fOverflow = true;
276         }
277       HLTDebug("LG channel (x = %d, z = %d) with amplitude: %f --> Digit with energy: %f\n", coord.fX, coord.fZ, channelData->fEnergy, fDigitStructPtr->fEnergy); 
278     }
279   fDigitStructPtr->fTime = channelData->fTime * 0.0000001; //TODO
280   fDigitStructPtr->fCrazyness = channelData->fCrazyness;
281   fDigitStructPtr->fModule = coord.fModuleId;
282   fDigitStructPtr = tmpDigit;
283   //  fDigitStructPtr++;
284   fDigitCount++;
285 }
286
287 bool AliHLTCaloDigitMaker::UseDigit(AliHLTCaloCoordinate &channelCoordinates, AliHLTCaloChannelDataStruct *channel) 
288 {
289    
290    if(fBadChannelMask[channelCoordinates.fX][channelCoordinates.fZ][0] == true) return false;
291    if(channel->fTime < fMinTime || channel->fTime > fMaxTime) return false;
292    
293   AliHLTCaloDigitDataStruct *tmpDigit = fChannelBook[channelCoordinates.fX][channelCoordinates.fZ];
294   //printf("UseDigit: Got digit, x: %d, z: %d, gain: %d, amp: %f\n", channelCoordinates.fX, channelCoordinates.fZ, channelCoordinates.fGain, channel->fEnergy);
295   if(tmpDigit)
296     {
297       if(channelCoordinates.fGain == fCaloConstants->GetLOWGAIN())
298         {
299                   //printf("UseDigit: Already have digit with, x: %d, z: %d, with high gain \n", channelCoordinates.fX, channelCoordinates.fZ);
300           if(tmpDigit->fOverflow)
301             {
302                      // printf("But it was in overflow! Let's use this low gain!\n");
303               return true;
304             }
305           return false;
306         }
307       else
308         {
309                   //printf("UseDigit: Already have digit with, x: %d, z: %d, with low gain: %d\n", channelCoordinates.fX, channelCoordinates.fZ);
310           if(channel->fEnergy > fMaxEnergy )
311             {
312               tmpDigit->fHgPresent = true;
313               return false;
314             }
315           return true;
316         }
317     }
318   return true;
319 }
320
321 void AliHLTCaloDigitMaker::SetBadChannel(Int_t x, Int_t z, Bool_t bad)
322 {
323    // See header file for class documentation
324    fBadChannelMask[x][z][0] = bad;
325    fBadChannelMask[x][z][1] = bad;
326 }
327
328 void AliHLTCaloDigitMaker::SetGain(Int_t x, Int_t z, Float_t ratio, Float_t gain)
329 {
330    // See header file for class documentation
331    HLTDebug("Applying gain: %f for channel x: %d, z: %d", gain, x, z); 
332    fHighGainFactors[x][z] = gain;
333    fLowGainFactors[x][z] = gain * ratio;
334    
335 }