Update master to aliroot
[u/mrichter/AliRoot.git] / HLT / CALO / AliHLTCaloDigitMaker.cxx
CommitLineData
c683985a 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
44ClassImp(AliHLTCaloDigitMaker);
45
46//using namespace CaloHLTConst;
47
48AliHLTCaloDigitMaker::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
99AliHLTCaloDigitMaker::~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
110Int_t
111AliHLTCaloDigitMaker::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
163void
164AliHLTCaloDigitMaker::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
177void
178AliHLTCaloDigitMaker::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
191void
192AliHLTCaloDigitMaker::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
218void
219AliHLTCaloDigitMaker::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
233void 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
287bool 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
321void 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
328void 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}