]>
Commit | Line | Data |
---|---|---|
1b41ab20 | 1 | // $Id$ |
2 | ||
2374af72 | 3 | /************************************************************************** |
4 | * This file is property of and copyright by the ALICE HLT Project * | |
5 | * All rights reserved. * | |
6 | * * | |
7 | * Primary Authors: Oystein Djuvsland * | |
36f19b25 | 8 | * * |
2374af72 | 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 AliHLTPHOSClusterizer.cxx | |
19 | * @author Oystein Djuvsland | |
20 | * @date | |
d949e02e | 21 | * @brief Digit maker for PHOS HLT |
2374af72 | 22 | */ |
94594220 | 23 | |
24 | ||
25 | ||
2374af72 | 26 | |
27 | // see header file for class documentation | |
28 | // or | |
29 | // refer to README to build package | |
30 | // or | |
31 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
209a4703 | 32 | |
33 | #include "AliHLTPHOSDigitMaker.h" | |
18af2efc | 34 | |
209a4703 | 35 | #include "AliHLTPHOSConstants.h" |
94594220 | 36 | #include "AliHLTPHOSMapper.h" |
209a4703 | 37 | |
94594220 | 38 | #include "AliHLTPHOSChannelDataStruct.h" |
39 | #include "AliHLTPHOSChannelDataHeaderStruct.h" | |
209a4703 | 40 | #include "AliHLTPHOSDigitDataStruct.h" |
94594220 | 41 | #include "AliHLTPHOSSharedMemoryInterfacev2.h" // added by PTH |
87434909 | 42 | #include "AliPHOSEMCAGeometry.h" |
e304ea31 | 43 | #include "TH2F.h" |
2374af72 | 44 | |
45 | ClassImp(AliHLTPHOSDigitMaker); | |
209a4703 | 46 | |
47 | using namespace PhosHLTConst; | |
48 | ||
49 | AliHLTPHOSDigitMaker::AliHLTPHOSDigitMaker() : | |
50 | AliHLTPHOSBase(), | |
04da0321 | 51 | fShmPtr(0), |
d949e02e | 52 | fDigitStructPtr(0), |
8394d59f | 53 | fDigitCount(0), |
e304ea31 | 54 | fOrdered(true), |
55 | fMapperPtr(0) | |
209a4703 | 56 | { |
2374af72 | 57 | // See header file for documentation |
94594220 | 58 | |
59 | fShmPtr = new AliHLTPHOSSharedMemoryInterfacev2(); | |
60 | ||
27029341 | 61 | for(int x = 0; x < NXCOLUMNSMOD; x++) |
25b7f84c | 62 | { |
27029341 | 63 | for(int z = 0; z < NZROWSMOD; z++) |
25b7f84c | 64 | { |
65 | fHighGainFactors[x][z] = 0.005; | |
66 | fLowGainFactors[x][z] = 0.08; | |
27029341 | 67 | fBadChannelMask[x][z][HIGHGAIN] = 1; |
68 | fBadChannelMask[x][z][LOWGAIN] = 1; | |
25b7f84c | 69 | } |
e304ea31 | 70 | } |
71 | fMapperPtr = new AliHLTPHOSMapper(); | |
209a4703 | 72 | } |
7ce40e5c | 73 | |
209a4703 | 74 | AliHLTPHOSDigitMaker::~AliHLTPHOSDigitMaker() |
75 | { | |
2374af72 | 76 | //See header file for documentation |
209a4703 | 77 | } |
78 | ||
79 | Int_t | |
e304ea31 | 80 | AliHLTPHOSDigitMaker::MakeDigits(AliHLTPHOSChannelDataHeaderStruct* channelDataHeader, AliHLTUInt32_t availableSize) |
209a4703 | 81 | { |
2374af72 | 82 | //See header file for documentation |
25b7f84c | 83 | |
209a4703 | 84 | Int_t j = 0; |
e304ea31 | 85 | UInt_t totSize = sizeof(AliHLTPHOSDigitDataStruct); |
86 | ||
94594220 | 87 | // Int_t xMod = -1; |
88 | // Int_t zMod = -1; | |
89 | ||
94594220 | 90 | UShort_t coord1[4]; |
91 | UShort_t coord2[4]; | |
87434909 | 92 | Float_t locCoord[3]; |
94594220 | 93 | |
94 | ||
95 | AliHLTPHOSChannelDataStruct* currentchannel = 0; | |
96 | AliHLTPHOSChannelDataStruct* currentchannelLG = 0; | |
97 | AliHLTPHOSChannelDataStruct* tmpchannel = 0; | |
e304ea31 | 98 | |
94594220 | 99 | fShmPtr->SetMemory(channelDataHeader); |
7ce40e5c | 100 | currentchannel = fShmPtr->NextChannel(); |
7ce40e5c | 101 | |
94594220 | 102 | while(currentchannel != 0) |
14ff16ed | 103 | { |
e304ea31 | 104 | if(availableSize < totSize) return -1; |
105 | ||
94594220 | 106 | AliHLTPHOSMapper::GetChannelCoord(currentchannel->fChannelID, coord1); |
e304ea31 | 107 | |
108 | if(fOrdered) // High gain comes before low gain | |
109 | { | |
94594220 | 110 | tmpchannel = currentchannel; |
e304ea31 | 111 | |
27029341 | 112 | if(coord1[2] == HIGHGAIN) // We got a completely new crystal |
d949e02e | 113 | { |
94594220 | 114 | |
27029341 | 115 | if(currentchannel->fEnergy < MAXBINVALUE) // Make sure we don't have signal overflow |
94594220 | 116 | { |
87434909 | 117 | AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord); |
118 | AddDigit(currentchannel, coord1, locCoord); | |
94594220 | 119 | j++; |
e304ea31 | 120 | totSize += sizeof(AliHLTPHOSDigitDataStruct); |
121 | ||
122 | currentchannel = fShmPtr->NextChannel(); // Get the next channel | |
123 | ||
124 | if(currentchannel != 0) // There was a next channel! | |
d8122453 | 125 | { |
e304ea31 | 126 | AliHLTPHOSMapper::GetChannelCoord(currentchannel->fChannelID, coord2); |
127 | if(coord1[0] == coord2[0] && coord1[1] == coord2[1]) // Did we get the low gain channel for this crystal? | |
128 | { | |
129 | currentchannel = fShmPtr->NextChannel(); // In that case, jump to next channel | |
130 | } | |
d8122453 | 131 | } |
94594220 | 132 | } |
e304ea31 | 133 | |
134 | else // Ooops, overflow, we try the next channel... | |
94594220 | 135 | { |
87434909 | 136 | |
94594220 | 137 | currentchannel = fShmPtr->NextChannel(); |
e304ea31 | 138 | if(currentchannel != 0) // There was a next channel |
94594220 | 139 | { |
e304ea31 | 140 | AliHLTPHOSMapper::GetChannelCoord(currentchannel->fChannelID, coord2); |
141 | if(coord2[0] == coord1[0] && coord2[1] == coord1[1]) // It is a low gain channel with the same coordinates, we may use it | |
142 | { | |
87434909 | 143 | AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord); |
144 | AddDigit(currentchannel, coord2, locCoord); | |
e304ea31 | 145 | j++; |
146 | totSize += sizeof(AliHLTPHOSDigitDataStruct); | |
147 | currentchannel = fShmPtr->NextChannel(); | |
148 | } | |
149 | ||
150 | else // No low gain channel with information about the overflow channel so we just use the overflowed one... | |
151 | { | |
87434909 | 152 | AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord); |
153 | AddDigit(tmpchannel, coord1, locCoord); | |
e304ea31 | 154 | j++; |
155 | totSize += sizeof(AliHLTPHOSDigitDataStruct); | |
156 | // no need to get the next channel here, we already did... | |
157 | } | |
158 | ||
94594220 | 159 | } |
94594220 | 160 | } |
161 | } | |
e304ea31 | 162 | else // Well, there seem to be missing a high gain channel for this crystal, let's use the low gain one |
87434909 | 163 | { |
164 | AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord); | |
165 | AddDigit(tmpchannel, coord1, locCoord); | |
94594220 | 166 | j++; |
e304ea31 | 167 | totSize += sizeof(AliHLTPHOSDigitDataStruct); |
168 | currentchannel = fShmPtr->NextChannel(); | |
d949e02e | 169 | } |
94594220 | 170 | |
171 | } | |
e304ea31 | 172 | else //Reversed ordered (low gain before high gain) |
94594220 | 173 | { |
27029341 | 174 | if(coord1[2] == LOWGAIN) // We got a new channel! |
d949e02e | 175 | { |
e304ea31 | 176 | currentchannelLG = currentchannel; // Ok, let's back up the low gain channel and look for the fancy high gain one |
94594220 | 177 | currentchannel = fShmPtr->NextChannel(); |
e304ea31 | 178 | |
179 | if(currentchannel != 0) //There was another channel in the event | |
94594220 | 180 | { |
e304ea31 | 181 | AliHLTPHOSMapper::GetChannelCoord(currentchannel->fChannelID, coord2); |
182 | ||
183 | if(coord1[0] == coord2[0] && coord1[1] == coord2[1]) // Aha! Found the high gain channel | |
94594220 | 184 | { |
27029341 | 185 | if(currentchannel->fEnergy < MAXBINVALUE) // To overflow or not to overflow? |
e304ea31 | 186 | { |
87434909 | 187 | AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord); |
188 | AddDigit(currentchannel, coord2, locCoord); | |
e304ea31 | 189 | j++; |
190 | totSize += sizeof(AliHLTPHOSDigitDataStruct); | |
191 | currentchannel = fShmPtr->NextChannel(); | |
192 | } | |
193 | else // Oh well, better use the low gain channel then | |
194 | { | |
87434909 | 195 | // cout << "Reverse: Overflow!" << endl; |
196 | AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord); | |
197 | AddDigit(currentchannelLG, coord1, locCoord); | |
e304ea31 | 198 | j++; |
199 | totSize += sizeof(AliHLTPHOSDigitDataStruct); | |
200 | currentchannel = fShmPtr->NextChannel(); | |
201 | } | |
94594220 | 202 | } |
18af2efc | 203 | else // No available high gain channel for this crystal, adding the low gain one |
94594220 | 204 | { |
87434909 | 205 | AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord); |
206 | AddDigit(currentchannelLG, coord1, locCoord); | |
94594220 | 207 | j++; |
e304ea31 | 208 | totSize += sizeof(AliHLTPHOSDigitDataStruct); |
94594220 | 209 | } |
210 | } | |
18af2efc | 211 | else //Fine, no more channels, better add this one... |
94594220 | 212 | { |
87434909 | 213 | AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord); |
214 | AddDigit(currentchannelLG, coord1, locCoord); | |
d949e02e | 215 | j++; |
e304ea31 | 216 | totSize += sizeof(AliHLTPHOSDigitDataStruct); |
d949e02e | 217 | } |
e304ea31 | 218 | } |
219 | else // Cool, no annoying low gain channel for this channel | |
94594220 | 220 | { |
87434909 | 221 | AliHLTPHOSMapper::GetLocalCoord(currentchannel->fChannelID, locCoord); |
222 | AddDigit(currentchannel, coord1, locCoord); | |
94594220 | 223 | j++; |
e304ea31 | 224 | currentchannel = fShmPtr->NextChannel(); |
94594220 | 225 | } |
14ff16ed | 226 | } |
14ff16ed | 227 | } |
94594220 | 228 | |
14ff16ed | 229 | fDigitCount += j; |
230 | return fDigitCount; | |
231 | } | |
232 | ||
d949e02e | 233 | void |
234 | AliHLTPHOSDigitMaker::SetGlobalHighGainFactor(Float_t factor) | |
209a4703 | 235 | { |
d949e02e | 236 | //See header file for documentation |
27029341 | 237 | for(int x = 0; x < NXCOLUMNSMOD; x++) |
d949e02e | 238 | { |
27029341 | 239 | for(int z = 0; z < NZROWSMOD; z++) |
d949e02e | 240 | { |
241 | fHighGainFactors[x][z] = factor; | |
242 | } | |
243 | } | |
209a4703 | 244 | } |
209a4703 | 245 | |
246 | void | |
d949e02e | 247 | AliHLTPHOSDigitMaker::SetGlobalLowGainFactor(Float_t factor) |
248 | { | |
249 | //See header file for documentation | |
27029341 | 250 | for(int x = 0; x < NXCOLUMNSMOD; x++) |
d949e02e | 251 | { |
27029341 | 252 | for(int z = 0; z < NZROWSMOD; z++) |
d949e02e | 253 | { |
254 | fLowGainFactors[x][z] = factor; | |
255 | } | |
256 | } | |
209a4703 | 257 | } |
258 | ||
7ce40e5c | 259 | void |
260 | AliHLTPHOSDigitMaker::SetBadChannelMask(TH2F* badChannelHGHist, TH2F* badChannelLGHist, Float_t qCut) | |
261 | { | |
27029341 | 262 | for(int x = 0; x < NXCOLUMNSMOD; x++) |
7ce40e5c | 263 | { |
27029341 | 264 | for(int z = 0; z < NZROWSMOD; z++) |
7ce40e5c | 265 | { |
266 | if(badChannelHGHist->GetBinContent(x, z) < qCut && badChannelHGHist->GetBinContent(x, z) > 0) | |
267 | { | |
27029341 | 268 | fBadChannelMask[x][z][HIGHGAIN] = 1; |
7ce40e5c | 269 | } |
270 | else | |
271 | { | |
27029341 | 272 | fBadChannelMask[x][z][HIGHGAIN] = 0; |
7ce40e5c | 273 | } |
274 | if(badChannelLGHist->GetBinContent(x, z) < qCut && badChannelLGHist->GetBinContent(x, z) > 0) | |
275 | { | |
27029341 | 276 | fBadChannelMask[x][z][LOWGAIN] = 0; |
7ce40e5c | 277 | } |
278 | else | |
279 | { | |
27029341 | 280 | fBadChannelMask[x][z][LOWGAIN] = 0; |
7ce40e5c | 281 | } |
282 | } | |
283 | } | |
284 | } | |
e304ea31 | 285 |