]>
Commit | Line | Data |
---|---|---|
1e7c9b89 | 1 | /************************************************************************** |
3a8be91c | 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 | /* $Id$ */ | |
feedcab9 | 17 | |
3a8be91c | 18 | //----------------------------------------------------------------------------- |
19 | // Container of EMCAL reconstruction parameters | |
20 | // The purpose of this object is to store it to OCDB | |
1e7c9b89 | 21 | // and retrieve it in the corresponding reconstruction class: |
22 | // AliEMCALClusterizer, AliEMCALPID, AliEMCALTracker ... | |
23 | // | |
3a8be91c | 24 | // Author: Yuri Kharlov |
25 | //----------------------------------------------------------------------------- | |
26 | ||
1e7c9b89 | 27 | // --- Root header files |
28 | //#include "TObjArray.h" | |
29 | ||
30 | // --- AliRoot header files --- | |
31 | #include "AliCDBManager.h" | |
32 | #include "AliCDBEntry.h" | |
33 | #include "AliEMCALRecParam.h" | |
34 | ||
35 | ClassImp(AliEMCALRecParam) | |
a0945e6f | 36 | |
ee08edde | 37 | TObjArray* AliEMCALRecParam::fgkMaps =0; //ALTRO mappings |
1e7c9b89 | 38 | |
413e6b81 | 39 | AliEMCALRecParam::AliEMCALRecParam() : |
a0945e6f | 40 | AliDetectorRecoParam(), |
41 | fClusteringThreshold(0.1), | |
42 | fW0(4.5), | |
43 | fMinECut(0.05), | |
44 | fUnfold(kFALSE), | |
45 | fLocMaxCut(0.03), | |
46 | fTimeCut(1.),// high value, accept all | |
47 | fTimeMin(-1.),// small value, accept all | |
48 | fTimeMax(1.),// high value, accept all//clustering | |
49 | fClusterizerFlag(AliEMCALRecParam::kClusterizerv1), | |
50 | fNRowDiff(1), | |
51 | fNColDiff(1), | |
52 | fMthCutEta(0.025), | |
53 | fMthCutPhi(0.05), | |
54 | fStep(20), | |
55 | fTrkCutPt(0.0), | |
56 | fTrkCutNITS(1.0), | |
57 | fTrkCutNTPC(20.0), //track matching | |
58 | fHighLowGainFactor(16.0), | |
59 | fOrderParameter(2), | |
60 | fTau(2.35), | |
61 | fNoiseThreshold(3), | |
62 | fNPedSamples(5), | |
63 | fRemoveBadChannels(kFALSE), | |
64 | fFittingAlgorithm(0), | |
65 | fUseFALTRO(kTRUE), | |
66 | fFitLEDEvents(kFALSE)//raw signal | |
c47157cd | 67 | { |
68 | // default reco values | |
1e7c9b89 | 69 | |
70 | // PID parameters for Pb Pb from Lambda0 distributions fitted by | |
71 | // a landau inverted + Gaussian for Gammas | |
72 | // and a Landau +Gaussian for Pi0 and hadrons | |
73 | // New parametrisation for | |
74 | // lambda0^2 (=x): f(x) = normLandau*TMath::Landau(((1-mpvlandau)-x),mpvLandau,widthLandau)+normgaus*TMath::Gaus(x,meangaus,sigmagaus) for gammas | |
75 | // lambda0^2 (=x): f(x) = normLandau*TMath::Landau(x,mpvLandau,widthLandau)+normgaus*TMath::Gaus(x,meangaus,sigmagaus) for pi0 & hadrons | |
76 | ||
77 | // See AliEMCALPid | |
78 | // (index i) refers to each parameters of the f(lambda0^2) | |
79 | // i=0: normGaus | |
80 | // i=1: meanGaus | |
81 | // i=2: sigmaGaus | |
82 | // i=3: normLandau | |
83 | // i=4: mpvLandau | |
84 | // i=5: sigmaLanda | |
85 | // (index j) refers to the polynomial parameters of the fit of each parameter vs energy | |
86 | // Pb Pb | |
87 | ||
8ba062b1 | 88 | // as a first step, all array elements are initialized to 0.0 |
ee08edde | 89 | Int_t i=0, j=0; |
8ba062b1 | 90 | for (i = 0; i < 6; i++) { |
1e7c9b89 | 91 | for (j = 0; j < 6; j++) { |
92 | fGamma[i][j] = fPiZero[i][j] = fHadron[i][j] = 0.; | |
93 | fGamma1to10[i][j] = fHadron1to10[i][j]= 0.; | |
8ba062b1 | 94 | } |
9f467289 | 95 | fGammaEnergyProb[i] =0.; // not yet implemented |
1e7c9b89 | 96 | fHadronEnergyProb[i]=0.; |
97 | fPiZeroEnergyProb[i]=0.; // not yet implemented | |
98 | ||
99 | ||
8ba062b1 | 100 | } |
88cf6bfb | 101 | // Set here default parameters for Pb+Pb (high flux) |
8ba062b1 | 102 | |
1e7c9b89 | 103 | fGamma[0][0] = -7.656908e-01; |
104 | fGamma[0][1] = 2.352536e-01; | |
105 | fGamma[0][2] = 1.555996e-02; | |
106 | fGamma[0][3] = 2.243525e-04; | |
107 | fGamma[0][4] = -2.560087e-06; | |
108 | ||
109 | fGamma[1][0] = 6.500216e+00; | |
110 | fGamma[1][1] = -2.564958e-01; | |
111 | fGamma[1][2] = 1.967894e-01; | |
112 | fGamma[1][3] = -3.982273e-04; | |
113 | fGamma[1][4] = 2.797737e-06; | |
114 | ||
115 | fGamma[2][0] = 2.416489e+00; | |
116 | fGamma[2][1] = -1.601258e-01; | |
117 | fGamma[2][2] = 3.126839e-02; | |
118 | fGamma[2][3] = 3.387532e-04; | |
119 | fGamma[2][4] = -4.089145e-06; | |
120 | ||
121 | ||
122 | fGamma[3][0] = 0.; | |
123 | fGamma[3][1] = -2.696008e+00; | |
124 | fGamma[3][2] = 6.920305e-01; | |
125 | fGamma[3][3] = -2.281122e-03; | |
126 | fGamma[3][4] = 0.; | |
127 | ||
128 | fGamma[4][0] = 2.281564e-01; | |
129 | fGamma[4][1] = -7.575040e-02; | |
130 | fGamma[4][2] = 3.813423e-01; | |
131 | fGamma[4][3] = -1.243854e-04; | |
132 | fGamma[4][4] = 1.232045e-06; | |
133 | ||
134 | fGamma[5][0] = -3.290107e-01; | |
135 | fGamma[5][1] = 3.707545e-02; | |
136 | fGamma[5][2] = 2.917397e-03; | |
137 | fGamma[5][3] = 4.695306e-05; | |
138 | fGamma[5][4] = -3.572981e-07; | |
139 | ||
140 | ||
141 | fHadron[0][0] = 1.519112e-01; | |
142 | fHadron[0][1] = -8.267603e-02; | |
143 | fHadron[0][2] = 1.914574e-02; | |
144 | fHadron[0][3] = -2.677921e-04; | |
145 | fHadron[0][4] = 5.447939e-06; | |
146 | ||
147 | ||
148 | fHadron[1][0] = 0.; | |
149 | fHadron[1][1] = -7.549870e-02; | |
150 | fHadron[1][2] = 3.930087e-01; | |
151 | fHadron[1][3] = -2.368500e-03; | |
152 | fHadron[1][4] = 0.; | |
153 | ||
1e7c9b89 | 154 | fHadron[2][0] = 0.; |
155 | fHadron[2][1] = -2.463152e-02; | |
156 | fHadron[2][2] = 1.349257e-01; | |
157 | fHadron[2][3] = -1.089440e-03; | |
158 | fHadron[2][4] = 0.; | |
159 | ||
1e7c9b89 | 160 | fHadron[3][0] = 0.; |
161 | fHadron[3][1] = 5.101560e-01; | |
162 | fHadron[3][2] = 1.458679e-01; | |
163 | fHadron[3][3] = 4.903068e-04; | |
164 | fHadron[3][4] = 0.; | |
165 | ||
166 | fHadron[4][0] = 0.; | |
167 | fHadron[4][1] = -6.693943e-03; | |
168 | fHadron[4][2] = 2.444753e-01; | |
169 | fHadron[4][3] = -5.553749e-05; | |
170 | fHadron[4][4] = 0.; | |
171 | ||
172 | fHadron[5][0] = -4.414030e-01; | |
173 | fHadron[5][1] = 2.292277e-01; | |
174 | fHadron[5][2] = -2.433737e-02; | |
175 | fHadron[5][3] = 1.758422e-03; | |
176 | fHadron[5][4] = -3.001493e-05; | |
177 | ||
178 | ||
179 | fPiZero[0][0] = 5.072157e-01; | |
180 | fPiZero[0][1] = -5.352747e-01; | |
181 | fPiZero[0][2] = 8.499259e-02; | |
182 | fPiZero[0][3] = -3.687401e-03; | |
183 | fPiZero[0][4] = 5.482280e-05; | |
184 | ||
185 | ||
186 | fPiZero[1][0] = 4.590137e+02; | |
187 | fPiZero[1][1] = -7.079341e+01; | |
188 | fPiZero[1][2] = 4.990735e+00; | |
189 | fPiZero[1][3] = -1.241302e-01; | |
190 | fPiZero[1][4] = 1.065772e-03; | |
191 | ||
192 | ||
193 | fPiZero[2][0] = 1.376415e+02; | |
194 | fPiZero[2][1] = -3.031577e+01; | |
195 | fPiZero[2][2] = 2.474338e+00; | |
196 | fPiZero[2][3] = -6.903410e-02; | |
197 | fPiZero[2][4] = 6.244089e-04; | |
198 | ||
199 | fPiZero[3][0] = 0.; | |
200 | fPiZero[3][1] = 1.145983e+00; | |
201 | fPiZero[3][2] = -2.476052e-01; | |
202 | fPiZero[3][3] = 1.367373e-02; | |
203 | fPiZero[3][4] = 0.; | |
204 | ||
205 | fPiZero[4][0] = -2.097586e+02; | |
206 | fPiZero[4][1] = 6.300800e+01; | |
207 | fPiZero[4][2] = -4.038906e+00; | |
208 | fPiZero[4][3] = 1.088543e-01; | |
209 | fPiZero[4][4] = -9.362485e-04; | |
210 | ||
211 | fPiZero[5][0] = -1.671477e+01; | |
212 | fPiZero[5][1] = 2.995415e+00; | |
213 | fPiZero[5][2] = -6.040360e-02; | |
214 | fPiZero[5][3] = -6.137459e-04; | |
215 | fPiZero[5][4] = 1.847328e-05; | |
a0945e6f | 216 | |
1e7c9b89 | 217 | fHadronEnergyProb[0]= 0.; |
218 | fHadronEnergyProb[1]= 0.; | |
219 | fHadronEnergyProb[2]= 6.188452e-02; | |
220 | fHadronEnergyProb[3]= 2.030230e+00; | |
221 | fHadronEnergyProb[4]= -6.402242e-02; | |
222 | ||
65bec413 | 223 | //unfolding |
224 | fSSPars[0] = 0.9262; | |
225 | fSSPars[1] = 3.365; | |
226 | fSSPars[2] = 1.548; | |
227 | fSSPars[3] = 0.1625; | |
228 | fSSPars[4] = -0.4195; | |
229 | fSSPars[5] = 0.; | |
230 | fSSPars[6] = 0.; | |
231 | fSSPars[7] = 2.332; | |
232 | fPar5[0] = 12.31; | |
233 | fPar5[1] = -0.007381; | |
234 | fPar5[2] = -0.06936; | |
235 | fPar6[0] = 0.05452; | |
236 | fPar6[1] = 0.0001228; | |
237 | fPar6[2] = 0.001361; | |
a0945e6f | 238 | |
1e7c9b89 | 239 | } |
8ba062b1 | 240 | |
413e6b81 | 241 | //----------------------------------------------------------------------------- |
242 | AliEMCALRecParam::AliEMCALRecParam(const AliEMCALRecParam& rp) : | |
a0945e6f | 243 | AliDetectorRecoParam(), |
244 | fClusteringThreshold(rp.fClusteringThreshold), | |
245 | fW0(rp.fW0), | |
246 | fMinECut(rp.fMinECut), | |
247 | fUnfold(rp.fUnfold), | |
248 | fLocMaxCut(rp.fLocMaxCut), | |
249 | fTimeCut(rp.fTimeCut), | |
250 | fTimeMin(rp.fTimeMin), | |
251 | fTimeMax(rp.fTimeMax),//clustering | |
252 | fClusterizerFlag(rp.fClusterizerFlag), | |
253 | fNRowDiff(rp.fNRowDiff), | |
254 | fNColDiff(rp.fNColDiff), | |
255 | fMthCutEta(rp.fMthCutEta), | |
256 | fMthCutPhi(rp.fMthCutPhi), | |
257 | fStep(rp.fStep), | |
258 | fTrkCutPt(rp.fTrkCutPt), | |
259 | fTrkCutNITS(rp.fTrkCutNITS), | |
260 | fTrkCutNTPC(rp.fTrkCutNTPC), // track matching | |
261 | fHighLowGainFactor(rp.fHighLowGainFactor), | |
262 | fOrderParameter(rp.fOrderParameter), | |
263 | fTau(rp.fTau), | |
264 | fNoiseThreshold(rp.fNoiseThreshold), | |
265 | fNPedSamples(rp.fNPedSamples), | |
266 | fRemoveBadChannels(rp.fRemoveBadChannels), | |
267 | fFittingAlgorithm(rp.fFittingAlgorithm), | |
268 | fUseFALTRO(rp.fUseFALTRO), | |
269 | fFitLEDEvents(rp.fFitLEDEvents) //raw signal | |
413e6b81 | 270 | { |
271 | //copy constructor | |
1e7c9b89 | 272 | |
413e6b81 | 273 | //PID values |
ee08edde | 274 | Int_t i=0, j=0; |
413e6b81 | 275 | for (i = 0; i < 6; i++) { |
276 | for (j = 0; j < 6; j++) { | |
9f467289 | 277 | fGamma[i][j] = rp.fGamma[i][j]; |
278 | fGamma1to10[i][j] = rp.fGamma1to10[i][j]; | |
279 | fHadron[i][j] = rp.fHadron[i][j]; | |
1e7c9b89 | 280 | fHadron1to10[i][j] = rp.fHadron1to10[i][j]; |
9f467289 | 281 | fPiZero[i][j] = rp.fPiZero[i][j]; |
413e6b81 | 282 | } |
9f467289 | 283 | fGammaEnergyProb[i] = rp.fGammaEnergyProb[i]; |
1e7c9b89 | 284 | fPiZeroEnergyProb[i] = rp.fPiZeroEnergyProb[i]; |
285 | fHadronEnergyProb[i] = rp.fHadronEnergyProb[i]; | |
286 | ||
413e6b81 | 287 | } |
1e7c9b89 | 288 | |
65bec413 | 289 | //unfolding |
290 | for (i = 0; i < 8; i++) { | |
291 | fSSPars[i] = rp.fSSPars[i]; | |
292 | } | |
293 | for (i = 0; i < 3; i++) { | |
294 | fPar5[i] = rp.fPar5[i]; | |
295 | fPar6[i] = rp.fPar6[i]; | |
296 | } | |
a0945e6f | 297 | |
413e6b81 | 298 | } |
299 | ||
300 | //----------------------------------------------------------------------------- | |
301 | AliEMCALRecParam& AliEMCALRecParam::operator = (const AliEMCALRecParam& rp) | |
302 | { | |
303 | //assignment operator | |
1e7c9b89 | 304 | |
413e6b81 | 305 | if(this != &rp) { |
306 | fClusteringThreshold = rp.fClusteringThreshold; | |
9f467289 | 307 | fW0 = rp.fW0; |
308 | fMinECut = rp.fMinECut; | |
309 | fUnfold = rp.fUnfold; | |
a435f763 | 310 | fLocMaxCut = rp.fLocMaxCut; |
64c98165 | 311 | fTimeCut = rp.fTimeCut; |
312 | fTimeMax = rp.fTimeMax; | |
313 | fTimeMin = rp.fTimeMin;//clustering | |
5970dfe2 | 314 | fClusterizerFlag = rp.fClusterizerFlag; |
3c56da8f | 315 | fNRowDiff = rp.fNRowDiff; |
316 | fNColDiff = rp.fNColDiff; | |
5970dfe2 | 317 | fMthCutEta = rp.fMthCutEta; |
318 | fMthCutPhi = rp.fMthCutPhi; | |
319 | fStep = rp.fStep; | |
320 | fTrkCutPt = rp.fTrkCutPt; | |
321 | fTrkCutNITS = rp.fTrkCutNITS; | |
322 | fTrkCutNTPC = rp.fTrkCutNTPC; //track matching | |
413e6b81 | 323 | fHighLowGainFactor = rp.fHighLowGainFactor; |
9f467289 | 324 | fOrderParameter = rp.fOrderParameter; |
325 | fTau = rp.fTau; | |
326 | fNoiseThreshold = rp.fNoiseThreshold; | |
327 | fNPedSamples = rp.fNPedSamples; | |
328 | fRemoveBadChannels = rp.fRemoveBadChannels; | |
46f1d25f | 329 | fFittingAlgorithm = rp.fFittingAlgorithm; |
e853f058 | 330 | fUseFALTRO = rp.fUseFALTRO; |
64c98165 | 331 | fFitLEDEvents = rp.fFitLEDEvents;//raw signal |
9f467289 | 332 | |
413e6b81 | 333 | //PID values |
ee08edde | 334 | Int_t i=0, j=0; |
413e6b81 | 335 | for (i = 0; i < 6; i++) { |
336 | for (j = 0; j < 6; j++) { | |
a0945e6f | 337 | fGamma[i][j] = rp.fGamma[i][j]; |
338 | fGamma1to10[i][j] = rp.fGamma1to10[i][j]; | |
339 | fHadron[i][j] = rp.fHadron[i][j]; | |
340 | fHadron1to10[i][j] = rp.fHadron1to10[i][j]; | |
341 | fPiZero[i][j] = rp.fPiZero[i][j]; | |
413e6b81 | 342 | } |
9f467289 | 343 | fGammaEnergyProb[i] = rp.fGammaEnergyProb[i]; |
1e7c9b89 | 344 | fPiZeroEnergyProb[i] = rp.fPiZeroEnergyProb[i]; |
345 | fHadronEnergyProb[i] = rp.fHadronEnergyProb[i]; | |
413e6b81 | 346 | } |
65bec413 | 347 | //unfolding |
348 | for (i = 0; i < 8; i++) { | |
349 | fSSPars[i] = rp.fSSPars[i]; | |
350 | } | |
351 | for (i = 0; i < 3; i++) { | |
352 | fPar5[i] = rp.fPar5[i]; | |
353 | fPar6[i] = rp.fPar6[i]; | |
354 | } | |
a0945e6f | 355 | |
413e6b81 | 356 | } |
357 | ||
358 | return *this; | |
1e7c9b89 | 359 | |
413e6b81 | 360 | } |
361 | ||
362 | //----------------------------------------------------------------------------- | |
363 | AliEMCALRecParam* AliEMCALRecParam::GetDefaultParameters() | |
364 | { | |
365 | //default parameters for the reconstruction | |
88cf6bfb | 366 | AliEMCALRecParam* params = GetLowFluxParam(); |
367 | params->SetName("Default - p+p"); | |
368 | params->SetTitle("Default - p+p"); | |
f5fc991a | 369 | return params; |
1e7c9b89 | 370 | |
f5fc991a | 371 | } |
372 | ||
98cf874d | 373 | //----------------------------------------------------------------------------- |
374 | AliEMCALRecParam* AliEMCALRecParam::GetCalibParam() | |
375 | { | |
1e7c9b89 | 376 | //parameters for the reconstruction of calibration runs |
377 | AliEMCALRecParam* params = GetLowFluxParam(); | |
e658398a | 378 | //params->SetClusteringThreshold(0.1); // 100 MeV |
1e7c9b89 | 379 | //params->SetMinECut(0.01); //10 MeV |
380 | params->SetName("Calibration - LED"); | |
381 | params->SetTitle("Calibration - LED"); | |
382 | params->SetEventSpecie(AliRecoParam::kCalib); | |
383 | ||
384 | return params; | |
385 | ||
98cf874d | 386 | } |
387 | ||
388 | //----------------------------------------------------------------------------- | |
389 | AliEMCALRecParam* AliEMCALRecParam::GetCosmicParam() | |
390 | { | |
1e7c9b89 | 391 | //parameters for the reconstruction of cosmic runs |
392 | AliEMCALRecParam* params = GetLowFluxParam(); | |
e658398a | 393 | //params->SetClusteringThreshold(0.1); // 100 MeV |
1e7c9b89 | 394 | //params->SetMinECut(0.01); //10 MeV |
395 | params->SetName("Cosmic"); | |
396 | params->SetTitle("Cosmic"); | |
397 | params->SetEventSpecie(AliRecoParam::kCosmic); | |
398 | ||
399 | return params; | |
400 | ||
98cf874d | 401 | } |
f5fc991a | 402 | |
1e7c9b89 | 403 | |
f5fc991a | 404 | //----------------------------------------------------------------------------- |
405 | AliEMCALRecParam* AliEMCALRecParam::GetLowFluxParam() | |
406 | { | |
407 | //low flux/multiplicity ("p+p") parameters for the reconstruction | |
408 | AliEMCALRecParam* params = new AliEMCALRecParam(); | |
e658398a | 409 | params->SetClusteringThreshold(0.1); // 100 MeV |
f5fc991a | 410 | params->SetMinECut(0.01); //10 MeV |
411 | params->SetName("Low Flux - p+p"); | |
412 | params->SetTitle("Low Flux - p+p"); | |
413 | params->SetEventSpecie(AliRecoParam::kLowMult); | |
8fc351e3 | 414 | params->SetExtrapolateStep(1); |
1e7c9b89 | 415 | |
416 | ||
417 | //PID parameters for pp implemented | |
418 | // as a first step, all array elements are initialized to 0.0 | |
ee08edde | 419 | Int_t i=0, j=0; |
1e7c9b89 | 420 | for (i = 0; i < 6; i++) { |
421 | for (j = 0; j < 6; j++) { | |
422 | params->SetGamma(i,j,0.); | |
423 | params->SetGamma1to10(i,j,0.); | |
424 | params->SetHadron(i,j,0.); | |
425 | params->SetHadron1to10(i,j,0.); | |
426 | params->SetPiZero(i,j,0.); | |
427 | ||
428 | } | |
429 | params->SetGammaEnergyProb(i,0.); // not yet implemented | |
430 | params->SetHadronEnergyProb(i,0.); | |
431 | params->SetPiZeroEnergyProb(i,0.); // not yet implemented | |
432 | } | |
433 | ||
434 | ||
435 | params->SetGamma(0,0,-7.656908e-01); | |
436 | params->SetGamma(0,1,2.352536e-01); | |
437 | params->SetGamma(0,2,1.555996e-02); | |
438 | params->SetGamma(0,3,2.243525e-04); | |
439 | params->SetGamma(0,4,-2.560087e-06); | |
a0945e6f | 440 | |
1e7c9b89 | 441 | params->SetGamma(1,0,6.500216e+00); |
442 | params->SetGamma(1,1,-2.564958e-01); | |
443 | params->SetGamma(1,2,1.967894e-01); | |
444 | params->SetGamma(1,3,-3.982273e-04); | |
445 | params->SetGamma(1,4,2.797737e-06); | |
446 | ||
447 | params->SetGamma(2,0,2.416489e+00); | |
448 | params->SetGamma(2,1,-1.601258e-01); | |
449 | params->SetGamma(2,2,3.126839e-02); | |
450 | params->SetGamma(2,3,3.387532e-04); | |
451 | params->SetGamma(2,4,-4.089145e-06); | |
a0945e6f | 452 | |
1e7c9b89 | 453 | params->SetGamma(3,0,0.); |
454 | params->SetGamma(3,1,-2.696008e+00); | |
455 | params->SetGamma(3,2, 6.920305e-01); | |
456 | params->SetGamma(3,3,-2.281122e-03); | |
457 | params->SetGamma(3,4,0.); | |
a0945e6f | 458 | |
1e7c9b89 | 459 | params->SetGamma(4,0,2.281564e-01); |
460 | params->SetGamma(4,1,-7.575040e-02); | |
461 | params->SetGamma(4,2,3.813423e-01); | |
462 | params->SetGamma(4,3,-1.243854e-04); | |
463 | params->SetGamma(4,4,1.232045e-06); | |
a0945e6f | 464 | |
1e7c9b89 | 465 | params->SetGamma(5,0,-3.290107e-01); |
466 | params->SetGamma(5,1,3.707545e-02); | |
467 | params->SetGamma(5,2,2.917397e-03); | |
468 | params->SetGamma(5,3,4.695306e-05); | |
469 | params->SetGamma(5,4,-3.572981e-07); | |
a0945e6f | 470 | |
1e7c9b89 | 471 | params->SetHadron(0,0,9.482243e-01); |
472 | params->SetHadron(0,1,-2.780896e-01); | |
473 | params->SetHadron(0,2, 2.223507e-02); | |
474 | params->SetHadron(0,3,7.294263e-04); | |
475 | params->SetHadron(0,4,-5.665872e-06); | |
a0945e6f | 476 | |
1e7c9b89 | 477 | params->SetHadron(1,0,0.); |
478 | params->SetHadron(1,1,0.); | |
479 | params->SetHadron(1,2,2.483298e-01); | |
480 | params->SetHadron(1,3,0.); | |
481 | params->SetHadron(1,4,0.); | |
a0945e6f | 482 | |
1e7c9b89 | 483 | params->SetHadron(2,0,-5.601199e+00); |
484 | params->SetHadron(2,1,2.097382e+00); | |
485 | params->SetHadron(2,2,-2.307965e-01); | |
486 | params->SetHadron(2,3,9.206871e-03); | |
487 | params->SetHadron(2,4,-8.887548e-05); | |
a0945e6f | 488 | |
1e7c9b89 | 489 | params->SetHadron(3,0,6.543101e+00); |
490 | params->SetHadron(3,1,-2.305203e+00); | |
491 | params->SetHadron(3,2,2.761673e-01); | |
492 | params->SetHadron(3,3,-5.465855e-03); | |
493 | params->SetHadron(3,4,2.784329e-05); | |
a0945e6f | 494 | |
1e7c9b89 | 495 | params->SetHadron(4,0,-2.443530e+01); |
496 | params->SetHadron(4,1,8.902578e+00); | |
497 | params->SetHadron(4,2,-5.265901e-01); | |
498 | params->SetHadron(4,3,2.549111e-02); | |
499 | params->SetHadron(4,4,-2.196801e-04); | |
a0945e6f | 500 | |
1e7c9b89 | 501 | params->SetHadron(5,0,2.102007e-01); |
502 | params->SetHadron(5,1,-3.844418e-02); | |
503 | params->SetHadron(5,2,1.234682e-01); | |
504 | params->SetHadron(5,3,-3.866733e-03); | |
505 | params->SetHadron(5,4,3.362719e-05); | |
a0945e6f | 506 | |
1e7c9b89 | 507 | params->SetPiZero(0,0,5.07215e-01); |
508 | params->SetPiZero(0,1,-5.35274e-01); | |
509 | params->SetPiZero(0,2,8.49925e-02); | |
510 | params->SetPiZero(0,3,-3.68740e-03); | |
511 | params->SetPiZero(0,4,5.48228e-05); | |
a0945e6f | 512 | |
1e7c9b89 | 513 | params->SetPiZero(1,0,4.590137e+02); |
514 | params->SetPiZero(1,1,-7.079341e+01); | |
515 | params->SetPiZero(1,2,4.990735e+00); | |
516 | params->SetPiZero(1,3,-1.241302e-01); | |
517 | params->SetPiZero(1,4,1.065772e-03); | |
a0945e6f | 518 | |
1e7c9b89 | 519 | params->SetPiZero(2,0,1.376415e+02); |
520 | params->SetPiZero(2,1,-3.031577e+01); | |
521 | params->SetPiZero(2,2,2.474338e+00); | |
522 | params->SetPiZero(2,3,-6.903410e-02); | |
523 | params->SetPiZero(2,4,6.244089e-04); | |
a0945e6f | 524 | |
1e7c9b89 | 525 | params->SetPiZero(3,0,0.); |
526 | params->SetPiZero(3,1,1.145983e+00); | |
527 | params->SetPiZero(3,2,-2.476052e-01); | |
528 | params->SetPiZero(3,3,1.367373e-02); | |
529 | params->SetPiZero(3,4,0.); | |
a0945e6f | 530 | |
1e7c9b89 | 531 | params->SetPiZero(4,0,-2.09758e+02); |
532 | params->SetPiZero(4,1,6.30080e+01); | |
533 | params->SetPiZero(4,2,-4.03890e+00); | |
534 | params->SetPiZero(4,3,1.08854e-01); | |
535 | params->SetPiZero(4,4,-9.36248e-04); | |
a0945e6f | 536 | |
1e7c9b89 | 537 | params->SetPiZero(5,0,-1.671477e+01); |
538 | params->SetPiZero(5,1,2.995415e+00); | |
539 | params->SetPiZero(5,2,-6.040360e-02); | |
540 | params->SetPiZero(5,3,-6.137459e-04); | |
541 | params->SetPiZero(5,4,1.847328e-05); | |
a0945e6f | 542 | |
543 | ||
544 | // params->SetHadronEnergyProb(0,0.); | |
545 | // params->SetHadronEnergyProb(1,0.); | |
546 | // params->SetHadronEnergyProb(2,1.); | |
547 | // params->SetHadronEnergyProb(3,0.); | |
548 | // params->SetHadronEnergyProb(4,0.); | |
549 | ||
1e7c9b89 | 550 | params->SetHadronEnergyProb(0, 4.767543e-02); |
551 | params->SetHadronEnergyProb(1,-1.537523e+00); | |
552 | params->SetHadronEnergyProb(2,2.956727e-01); | |
553 | params->SetHadronEnergyProb(3,-3.051022e+01); | |
554 | params->SetHadronEnergyProb(4,-6.036931e-02); | |
a0945e6f | 555 | |
556 | // Int_t ii= 0; | |
557 | // Int_t jj= 3; | |
558 | // AliDebug(1,Form("PID parameters (%d, %d): fGamma=%.3f, fPi=%.3f, fHadron=%.3f", | |
559 | // ii,jj, params->GetGamma(ii,jj), params->GetPiZero(ii,jj), params->GetHadron(ii,jj))); | |
560 | // cout << " Low Flux Parameters fGamma [2][2] = " << params->GetGamma(2,2) << endl; | |
561 | // cout << " Low Flux Parameters fHadron [2][2] = " << params->GetHadron(2,2) << endl; | |
562 | ||
f5fc991a | 563 | return params; |
a0945e6f | 564 | |
f5fc991a | 565 | } |
566 | ||
567 | ||
568 | //----------------------------------------------------------------------------- | |
569 | AliEMCALRecParam* AliEMCALRecParam::GetHighFluxParam() | |
570 | { | |
571 | //high flux/multiplicity ("Pb+Pb") parameters for the reconstruction | |
572 | AliEMCALRecParam* params = new AliEMCALRecParam(); | |
573 | //For now, same as default | |
574 | //if later these need to be modified, here's where it is done | |
575 | params->SetName("High Flux - Pb+Pb"); | |
576 | params->SetTitle("High Flux - Pb+Pb"); | |
577 | params->SetEventSpecie(AliRecoParam::kHighMult); | |
5970dfe2 | 578 | params->SetTrkCutPt(0.15);//This value can be higher if necessary |
1e7c9b89 | 579 | |
413e6b81 | 580 | return params; |
1e7c9b89 | 581 | |
413e6b81 | 582 | } |
583 | ||
3a8be91c | 584 | //----------------------------------------------------------------------------- |
798a3f92 | 585 | void AliEMCALRecParam::Print(Option_t * opt) const |
3a8be91c | 586 | { |
3a8be91c | 587 | // Print reconstruction parameters to stdout |
798a3f92 | 588 | // if nothing is specified print all, if "reco" just clusterization/track matching |
589 | // if "pid", just PID parameters, if "raw", just raw utils parameters. | |
590 | if(!strcmp("",opt) || !strcmp("reco",opt)){ | |
ee08edde | 591 | AliInfo(Form("Clusterizer selected: %d", fClusterizerFlag)); |
9dce5a21 | 592 | AliInfo(Form("Clusterization parameters :\n fClusteringThreshold=%.3f,\n fW0=%.3f,\n fMinECut=%.3f,\n fUnfold=%d,\n fLocMaxCut=%.3f,\n fTimeCut=%2.1f ns\n fTimeMin=%2.1f ns\n fTimeMax=%2.1f ns\n", |
a0945e6f | 593 | fClusteringThreshold,fW0,fMinECut,fUnfold,fLocMaxCut,fTimeCut*1.e9,fTimeMin*1e9,fTimeMax*1e9)); |
798a3f92 | 594 | |
5970dfe2 | 595 | AliInfo(Form("Track-matching cuts :\n dEta<%f, dPhi<%f, step=%f[cm], pT>%f, NITS>%f, NTPC>%f\n", |
a0945e6f | 596 | fMthCutEta, fMthCutPhi, fStep, fTrkCutPt, fTrkCutNITS,fTrkCutNTPC)); |
597 | ||
65bec413 | 598 | AliInfo(Form("Unfolding parameters, Shower shape function :\n")); |
599 | for(Int_t i = 0; i < 8; i++){ | |
a0945e6f | 600 | printf(" %f, ", fSSPars[i]); |
65bec413 | 601 | } |
602 | printf("\n Parameter 5 : "); | |
603 | for(Int_t i = 0; i < 3; i++){ | |
604 | printf(" %f, ", fPar5[i]); | |
605 | } | |
606 | printf("\n Parameter 6 : "); | |
607 | for(Int_t i = 0; i < 3; i++){ | |
608 | printf(" %f, ", fPar6[i]); | |
609 | } | |
610 | printf("\n"); | |
8ba062b1 | 611 | } |
1e7c9b89 | 612 | |
798a3f92 | 613 | if(!strcmp("",opt) || !strcmp("pid",opt)){ |
614 | AliInfo(Form("PID parameters, Gamma :\n")); | |
615 | for(Int_t i = 0; i < 6; i++){ | |
616 | for(Int_t j = 0; j < 6; j++){ | |
a0945e6f | 617 | printf(" %f, ", fGamma[i][j]); |
798a3f92 | 618 | } |
619 | printf("\n"); | |
8ba062b1 | 620 | } |
798a3f92 | 621 | |
622 | ||
623 | AliInfo(Form("PID parameters, Hadron :\n")); | |
624 | for(Int_t i = 0; i < 6; i++){ | |
625 | for(Int_t j = 0; j < 6; j++){ | |
a0945e6f | 626 | printf(" %f, ", fHadron[i][j]); |
798a3f92 | 627 | } |
628 | printf("\n"); | |
629 | } | |
630 | ||
8ba062b1 | 631 | printf("\n"); |
798a3f92 | 632 | |
633 | AliInfo(Form("PID parameters, Pi0zero :\n")); | |
634 | for(Int_t i = 0; i < 6; i++){ | |
635 | for(Int_t j = 0; j < 6; j++){ | |
a0945e6f | 636 | printf(" %f, ", fPiZero[i][j]); |
798a3f92 | 637 | } |
638 | printf("\n"); | |
8ba062b1 | 639 | } |
798a3f92 | 640 | |
8ba062b1 | 641 | printf("\n"); |
798a3f92 | 642 | |
643 | } | |
a0945e6f | 644 | |
798a3f92 | 645 | if(!strcmp("",opt) || !strcmp("raw",opt)){ |
646 | AliInfo(Form("Raw signal parameters: \n gain factor=%f, order=%d, tau=%f, noise threshold=%d, nped samples=%d \n", | |
a0945e6f | 647 | fHighLowGainFactor,fOrderParameter,fTau,fNoiseThreshold,fNPedSamples)); |
64c98165 | 648 | AliInfo(Form("Raw signal: remove bad channels? %d, \n \t with fitting algorithm %d, \n \t Use FALTRO %d, Fit LED events %d \n", |
a0945e6f | 649 | fRemoveBadChannels, fFittingAlgorithm, fUseFALTRO, fFitLEDEvents)); |
8ba062b1 | 650 | } |
3a8be91c | 651 | } |
8ba062b1 | 652 | |
413e6b81 | 653 | //----------------------------------------------------------------------------- |
feedcab9 | 654 | const TObjArray* AliEMCALRecParam::GetMappings() |
655 | { | |
413e6b81 | 656 | //Returns array of AliAltroMappings for RCU0..RCUX. |
657 | //If not found, read it from OCDB. | |
1e7c9b89 | 658 | |
413e6b81 | 659 | //Quick check as follows: |
1e7c9b89 | 660 | // root [0] AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT" |
413e6b81 | 661 | // root [1] AliCDBManager::Instance()->SetRun(1); |
662 | // root [2] TObjArray* maps = AliEMCALRecParam::GetMappings(); | |
663 | // root [3] maps->Print(); | |
1e7c9b89 | 664 | |
feedcab9 | 665 | if(fgkMaps) return fgkMaps; |
1e7c9b89 | 666 | |
feedcab9 | 667 | AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/Mapping"); |
668 | if(entry) | |
669 | fgkMaps = (TObjArray*)entry->GetObject(); | |
1e7c9b89 | 670 | |
feedcab9 | 671 | return fgkMaps; |
1e7c9b89 | 672 | |
feedcab9 | 673 | } |
674 |