Line data Source code
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 : // ROOT includes
17 : #include "TMath.h"
18 : #include "TArrayD.h"
19 :
20 : // STEER includes
21 : #include "AliEMCALPIDUtils.h"
22 : #include "AliLog.h"
23 :
24 : /// \cond CLASSIMP
25 72 : ClassImp(AliEMCALPIDUtils) ;
26 : /// \endcond
27 :
28 : ///
29 : /// Constructor.
30 : /// Initialize all constant values which have to be used
31 : /// during PID algorithm execution.
32 : ///
33 : //______________________________________________________________________________
34 8 : AliEMCALPIDUtils::AliEMCALPIDUtils():
35 8 : fPrintInfo(kFALSE), fProbGamma(0.), fProbPiZero(0.), fProbHadron(0.),
36 8 : fWeightHadronEnergy(1.), fWeightGammaEnergy(1.), fWeightPiZeroEnergy(1.)
37 24 : {
38 8 : InitParameters();
39 8 : }
40 :
41 : ///
42 : /// This is the main command, which uses the distributions computed and parametrised,
43 : /// and gives the PID by the bayesian method.
44 : ///
45 : /// \param energy: cluster energy
46 : /// \param lambda0: cluster main shower axis
47 : ///
48 : //______________________________________________________________________________
49 : void AliEMCALPIDUtils::ComputePID(Double_t energy, Double_t lambda0)
50 : {
51 30 : Double_t weightGammaEnergy = DistEnergy(energy, 1);
52 15 : Double_t weightPiZeroEnergy = DistEnergy(energy, 2);
53 15 : Double_t weightHadronEnergy = DistEnergy(energy, 3);
54 :
55 : Double_t energyhadron = energy ;
56 :
57 22 : if ( energyhadron < 1. ) energyhadron = 1. ; // no energy dependance of parametrisation for hadrons below 1 GeV
58 :
59 22 : if ( energy < 2 ) energy = 2. ; // no energy dependance of parametrisation for gamma and pi0 below 2 GeV
60 :
61 15 : if ( energy > 55 )
62 : {
63 : energy = 55. ;
64 : energyhadron= 55. ;
65 0 : }
66 : // same parametrisation for gamma and hadrons above 55 GeV
67 : // for the pi0 above 55GeV the 2 gammas supperposed no way to distinguish from real gamma PIDWeight[1]=0
68 :
69 15 : TArrayD paramDistribGamma = DistLambda0(energy, 1);
70 15 : TArrayD paramDistribPiZero = DistLambda0(energy, 2);
71 15 : TArrayD paramDistribHadron = DistLambda0(energyhadron, 3);
72 :
73 : Bool_t norm = kFALSE;
74 :
75 75 : fProbGamma = TMath::Gaus(lambda0, paramDistribGamma[1], paramDistribGamma[2], norm) * paramDistribGamma[0];
76 90 : fProbGamma += TMath::Landau(((1-paramDistribGamma[4])-lambda0),paramDistribGamma[4],paramDistribGamma[5],norm)* paramDistribGamma[3];
77 22 : if(fProbGamma<0.)fProbGamma=0.;
78 :
79 15 : fProbGamma = fProbGamma*weightGammaEnergy;
80 :
81 15 : if ( energy > 10. || energy < 55. )
82 : {
83 75 : fProbPiZero = TMath::Gaus(lambda0, paramDistribPiZero[1], paramDistribPiZero[2], norm) * paramDistribPiZero[0];
84 75 : fProbPiZero += TMath::Landau(lambda0, paramDistribPiZero[4], paramDistribPiZero[5], norm) * paramDistribPiZero[3];
85 24 : if(fProbPiZero<0. || energy<5.)fProbPiZero=0.;
86 15 : fProbPiZero = fProbPiZero*weightPiZeroEnergy;
87 15 : }
88 : else
89 : {
90 0 : fProbPiZero = 0.;
91 : }
92 :
93 75 : fProbHadron = TMath::Gaus(lambda0, paramDistribHadron[1], paramDistribHadron[2], norm) * paramDistribHadron[0];
94 75 : fProbHadron += TMath::Landau(lambda0, paramDistribHadron[4], paramDistribHadron[5], norm) * paramDistribHadron[3];
95 15 : if(fProbHadron<0.)fProbHadron=0.;
96 15 : fProbHadron = fProbHadron*weightHadronEnergy; // to take into account the probability for a hadron to have a given reconstructed energy
97 :
98 : // compute PID Weight
99 15 : if( (fProbGamma + fProbPiZero + fProbHadron) > 0. )
100 : {
101 15 : fPIDWeight[0] = fProbGamma / (fProbGamma + fProbPiZero + fProbHadron);
102 15 : fPIDWeight[1] = fProbPiZero / (fProbGamma+fProbPiZero+fProbHadron);
103 15 : fPIDWeight[2] = fProbHadron / (fProbGamma+fProbPiZero+fProbHadron);
104 15 : }
105 : else
106 : {
107 : // cases where energy and lambda0 large, probably du to 2 clusters folded the clusters PID not assigned to hadron nor Pi0 nor gammas
108 0 : fPIDWeight[0] = 0.;
109 0 : fPIDWeight[1] = 0.;
110 0 : fPIDWeight[2] = 0.;
111 : }
112 :
113 : // cout << " PID[0] "<< fPIDWeight[0] << " PID[1] "<< fPIDWeight[1] << " PID[2] "<< fPIDWeight[2] << endl;
114 :
115 15 : SetPID(fPIDWeight[0], 0);
116 15 : SetPID(fPIDWeight[1], 1);
117 15 : SetPID(fPIDWeight[2], 2);
118 :
119 : // print pid Weight only for control
120 15 : if (fPrintInfo)
121 : {
122 0 : AliInfo(Form( "Energy in loop = %f", energy) );
123 0 : AliInfo(Form( "Lambda0 in loop = %f", lambda0) );
124 0 : AliInfo(Form( "fProbGamma in loop = %f", fProbGamma) );
125 0 : AliInfo(Form( "fProbaPiZero = %f", fProbPiZero ));
126 0 : AliInfo(Form( "fProbaHadron = %f", fProbHadron) );
127 0 : AliInfo(Form( "PIDWeight in loop = %f ||| %f ||| %f", fPIDWeight[0] , fPIDWeight[1], fPIDWeight[2]) );
128 0 : AliInfo("********************************************************" );
129 : }
130 :
131 : //default particles
132 15 : fPIDFinal[AliPID::kElectron] = fPIDWeight[0]/2; // photon
133 15 : fPIDFinal[AliPID::kMuon] = fPIDWeight[2]/8;
134 15 : fPIDFinal[AliPID::kPion] = fPIDWeight[2]/8;
135 15 : fPIDFinal[AliPID::kKaon] = fPIDWeight[2]/8;
136 15 : fPIDFinal[AliPID::kProton] = fPIDWeight[2]/8;
137 : //light nuclei
138 15 : fPIDFinal[AliPID::kDeuteron] = 0;
139 15 : fPIDFinal[AliPID::kTriton] = 0;
140 15 : fPIDFinal[AliPID::kHe3] = 0;
141 15 : fPIDFinal[AliPID::kAlpha] = 0;
142 : //neutral particles
143 15 : fPIDFinal[AliPID::kPhoton] = fPIDWeight[0]/2; // electron
144 15 : fPIDFinal[AliPID::kPi0] = fPIDWeight[1] ; // Pi0
145 15 : fPIDFinal[AliPID::kNeutron] = fPIDWeight[2]/8;
146 15 : fPIDFinal[AliPID::kKaon0] = fPIDWeight[2]/8;
147 15 : fPIDFinal[AliPID::kEleCon] = fPIDWeight[2]/8;
148 : //
149 15 : fPIDFinal[AliPID::kUnknown] = fPIDWeight[2]/8;
150 15 : }
151 :
152 : ///
153 : /// Compute the values of the parametrised distributions using the data initialised before.
154 : ///
155 : /// \param energy: cluster energy
156 : /// \param type: function type
157 : ///
158 : //______________________________________________________________________________
159 : TArrayD AliEMCALPIDUtils::DistLambda0(Double_t energy, Int_t type)
160 : {
161 : Double_t constGauss = 0., meanGauss = 0., sigmaGauss = 0.;
162 : Double_t constLandau=0., mpvLandau=0., sigmaLandau=0.;
163 135 : TArrayD distributionParam(6);
164 :
165 90 : switch (type)
166 : {
167 : case 1:
168 :
169 15 : constGauss = PolynomialMixed2(energy, fGamma[0]);
170 15 : meanGauss = PolynomialMixed2(energy, fGamma[1]);
171 15 : sigmaGauss = PolynomialMixed2(energy, fGamma[2]);
172 15 : constLandau = PolynomialMixed2(energy, fGamma[3]);
173 15 : mpvLandau = PolynomialMixed2(energy, fGamma[4]);
174 15 : sigmaLandau = PolynomialMixed2(energy, fGamma[5]);
175 :
176 15 : break;
177 :
178 : case 2:
179 :
180 15 : constGauss = PolynomialMixed2(energy, fPiZero[0]);
181 15 : meanGauss = PolynomialMixed2(energy, fPiZero[1]);
182 15 : sigmaGauss = PolynomialMixed2(energy, fPiZero[2]);
183 15 : constLandau = PolynomialMixed2(energy, fPiZero[3]);
184 15 : mpvLandau = PolynomialMixed2(energy, fPiZero[4]);
185 15 : sigmaLandau = PolynomialMixed2(energy, fPiZero[5]);
186 :
187 15 : break;
188 :
189 : case 3:
190 :
191 15 : constGauss = PolynomialMixed2(energy, fHadron[0]);
192 15 : meanGauss = PolynomialMixed2(energy, fHadron[1]);
193 15 : sigmaGauss = PolynomialMixed2(energy, fHadron[2]);
194 15 : constLandau = PolynomialMixed2(energy, fHadron[3]);
195 15 : mpvLandau = PolynomialMixed2(energy, fHadron[4]);
196 15 : sigmaLandau = PolynomialMixed2(energy, fHadron[5]);
197 :
198 15 : break;
199 : }
200 :
201 90 : distributionParam[0] = constGauss;
202 90 : distributionParam[1] = meanGauss;
203 90 : distributionParam[2] = sigmaGauss;
204 90 : distributionParam[3] = constLandau;
205 90 : distributionParam[4] = mpvLandau;
206 90 : distributionParam[5] = sigmaLandau;
207 :
208 : return distributionParam;
209 90 : }
210 :
211 : ///
212 : /// Compute the values of the weigh for a given energy the parametrised distribution using the data initialised before.
213 : ///
214 : /// \param energy: cluster energy
215 : /// \param type: function type
216 : ///
217 : //______________________________________________________________________________
218 : Double_t AliEMCALPIDUtils::DistEnergy(Double_t energy, Int_t type)
219 : {
220 : Double_t constante = 0. ;
221 :
222 135 : switch (type)
223 : {
224 : case 1:
225 : constante = 1.;
226 15 : break;
227 : case 2:
228 : constante = 1.;
229 15 : break;
230 : case 3:
231 15 : constante = PowerExp(energy, fHadronEnergyProb);
232 15 : break;
233 : }
234 :
235 : // cout << "Weight " << constante << " for energy "<< energy<< " GeV "<< endl;
236 :
237 45 : return constante;
238 : }
239 :
240 : ///
241 : /// Compute a polynomial for a given value of 'x'
242 : /// with the array of parameters passed as the second arg
243 : ///
244 : /// \param x: function x parameter, energy
245 : /// \param params: array of function parameters
246 : ///
247 : //______________________________________________________________________________
248 : Double_t AliEMCALPIDUtils::Polynomial(Double_t x, const Double_t *params) const
249 : {
250 0 : Double_t y = params[0];
251 0 : y += params[1] * x;
252 0 : y += params[2] * x * x;
253 0 : y += params[3] * x * x * x;
254 0 : y += params[4] * x * x * x * x;
255 0 : y += params[5] * x * x * x * x * x;
256 :
257 0 : return y;
258 : }
259 :
260 : ///
261 : /// Compute a polynomial for a given value of 'x'
262 : /// with the array of parameters passed as the second arg
263 : ///
264 : /// \param params: array of function parameters
265 : ///
266 : //______________________________________________________________________________
267 : Double_t AliEMCALPIDUtils::Polynomial0(const Double_t *params) const
268 : {
269 0 : Double_t y = params[0];
270 0 : return y;
271 : }
272 :
273 : ///
274 : /// Compute a polynomial for a given value of 'x'
275 : /// with the array of parameters passed as the second arg.
276 : /// Order 0.
277 : ///
278 : /// \param x: function x parameter, energy
279 : /// \param params: array of function parameters
280 : ///
281 : //______________________________________________________________________________
282 : Double_t AliEMCALPIDUtils::Polynomialinv(Double_t x, const Double_t *params) const
283 : {
284 : Double_t y = 0. ;
285 :
286 0 : if(x>0)
287 : {
288 0 : y = params[0];
289 0 : y += params[1] / x;
290 0 : y += params[2] / (x * x);
291 0 : y += params[3] / (x * x * x);
292 0 : y += params[4] / (x * x * x * x);
293 0 : y += params[5] / (x * x * x * x * x);
294 0 : }
295 :
296 0 : return y;
297 : }
298 :
299 : ///
300 : /// Compute a polynomial for a given value of 'x'
301 : /// with the array of parameters passed as the second arg.
302 : /// 3 parameters.
303 : ///
304 : /// \param x: function x parameter, energy
305 : /// \param params: array of function parameters
306 : ///
307 : //______________________________________________________________________________
308 : Double_t AliEMCALPIDUtils::PolynomialMixed1(Double_t x, const Double_t *params) const
309 : {
310 : Double_t y = 0. ;
311 :
312 0 : if ( x > 0 )
313 : {
314 0 : y = params[0] / x;
315 0 : y += params[1] ;
316 0 : y += params[2] * x ;
317 : // y += params[3] * 0.;
318 : // y += params[4] * 0.;
319 : // y += params[5] * 0.;
320 0 : }
321 :
322 0 : return y;
323 : }
324 :
325 : ///
326 : /// Compute a polynomial for a given value of 'x'
327 : /// with the array of parameters passed as the second arg.
328 : /// 5 parameters.
329 : ///
330 : /// \param x: function x parameter, energy
331 : /// \param params: array of function parameters
332 : ///
333 : //______________________________________________________________________________
334 : Double_t AliEMCALPIDUtils::PolynomialMixed2(Double_t x, const Double_t *params) const
335 : {
336 : Double_t y = 0.;
337 :
338 540 : if ( x > 0 )
339 : {
340 270 : y = params[0] / ( x * x);
341 270 : y += params[1] / x;
342 270 : y += params[2] ;
343 270 : y += params[3] * x ;
344 270 : y += params[4] * x * x ;
345 : // y += params[5] * 0.;
346 270 : }
347 :
348 270 : return y;
349 : }
350 :
351 : ///
352 : /// Compute a polynomial for a given value of 'x'
353 : /// with the array of parameters passed as the second arg
354 : /// par[0]*TMath::Power(x[0],par[1])
355 : /// par[0]*TMath::Exp((x[0]-par[1])*par[2]);
356 : ///
357 : /// \param x: function x parameter, energy
358 : /// \param params: array of function parameters
359 : ///
360 : //______________________________________________________________________________
361 : Double_t AliEMCALPIDUtils::PowerExp(Double_t x, const Double_t *params) const
362 : {
363 30 : Double_t y = params[0] *TMath::Power( x,params[1]);
364 15 : y += params[2] *TMath::Exp((x-params[3])*params[4]);
365 :
366 15 : return y;
367 : }
368 :
369 : ///
370 : /// Initialize PID parameters, depending on the use or not of the reconstructor
371 : /// and the kind of event type if the reconstructor is not used.
372 : ///
373 : //______________________________________________________________________________
374 : void AliEMCALPIDUtils::InitParameters()
375 : {
376 : // fWeightHadronEnergy=0.;
377 : // fWeightPiZeroEnergy=0.;
378 : // fWeightGammaEnergy=0.;
379 :
380 16 : fPIDWeight[0] = -1;
381 8 : fPIDWeight[1] = -1;
382 8 : fPIDWeight[2] = -1;
383 :
384 256 : for(Int_t i=0; i<AliPID::kSPECIESCN+1; i++)
385 120 : fPIDFinal[i]= 0;
386 :
387 : // init the parameters here instead of from loading from recparam
388 : // default parameters are PbPb parameters.
389 8 : SetHighFluxParam();
390 8 : }
391 :
392 : ///
393 : /// Set the default parameters for low multiplicity environment, proton-proton.
394 : ///
395 : //______________________________________________________________________________
396 : void AliEMCALPIDUtils::SetLowFluxParam()
397 : {
398 : // as a first step, all array elements are initialized to 0.0
399 : Int_t i=0, j=0;
400 :
401 0 : for (i = 0; i < 6; i++)
402 : {
403 0 : for (j = 0; j < 6; j++)
404 : {
405 0 : fGamma[i][j] = fHadron[i][j] = fPiZero[i][j] = 0.;
406 0 : fGamma1to10[i][j] = fHadron1to10[i][j] = 0.;
407 : }
408 : //Why we had the next 3 lines?
409 : //fGammaEnergyProb[i] = fGammaEnergyProb[i];
410 : //fPiZeroEnergyProb[i] = fPiZeroEnergyProb[i];
411 : //fHadronEnergyProb[i] = fHadronEnergyProb[i];
412 : }
413 :
414 : // New parameterization for lambda0^2 (=x): f(x) = normLandau*TMath::Landau(x,mpvLandau,widthLandau)+normgaus*TMath::Gaus(x,meangaus,sigmagaus)
415 : // See AliEMCALPid (index j) refers to the polynomial parameters of the fit of each parameter vs energy
416 : // pp
417 :
418 : // paramtype[0][j] = norm gauss
419 : // paramtype[1][j] = mean gaus
420 : // paramtype[2][j] = sigma gaus
421 : // paramtype[3][j] = norm landau
422 : // paramtype[4][j] = mpv landau
423 : // paramtype[5][j] = sigma landau
424 :
425 0 : fGamma[0][0] = -7.656908e-01;
426 0 : fGamma[0][1] = 2.352536e-01;
427 0 : fGamma[0][2] = 1.555996e-02;
428 0 : fGamma[0][3] = 2.243525e-04;
429 0 : fGamma[0][4] = -2.560087e-06;
430 :
431 0 : fGamma[1][0] = 6.500216e+00;
432 0 : fGamma[1][1] = -2.564958e-01;
433 0 : fGamma[1][2] = 1.967894e-01;
434 0 : fGamma[1][3] = -3.982273e-04;
435 0 : fGamma[1][4] = 2.797737e-06;
436 :
437 0 : fGamma[2][0] = 2.416489e+00;
438 0 : fGamma[2][1] = -1.601258e-01;
439 0 : fGamma[2][2] = 3.126839e-02;
440 0 : fGamma[2][3] = 3.387532e-04;
441 0 : fGamma[2][4] = -4.089145e-06;
442 :
443 0 : fGamma[3][0] = 0.;
444 0 : fGamma[3][1] = -2.696008e+00;
445 0 : fGamma[3][2] = 6.920305e-01;
446 0 : fGamma[3][3] = -2.281122e-03;
447 0 : fGamma[3][4] = 0.;
448 :
449 0 : fGamma[4][0] = 2.281564e-01;
450 0 : fGamma[4][1] = -7.575040e-02;
451 0 : fGamma[4][2] = 3.813423e-01;
452 0 : fGamma[4][3] = -1.243854e-04;
453 0 : fGamma[4][4] = 1.232045e-06;
454 :
455 0 : fGamma[5][0] = -3.290107e-01;
456 0 : fGamma[5][1] = 3.707545e-02;
457 0 : fGamma[5][2] = 2.917397e-03;
458 0 : fGamma[5][3] = 4.695306e-05;
459 0 : fGamma[5][4] = -3.572981e-07;
460 :
461 0 : fHadron[0][0] = 9.482243e-01;
462 0 : fHadron[0][1] = -2.780896e-01;
463 0 : fHadron[0][2] = 2.223507e-02;
464 0 : fHadron[0][3] = 7.294263e-04;
465 0 : fHadron[0][4] = -5.665872e-06;
466 :
467 0 : fHadron[1][0] = 0.;
468 0 : fHadron[1][1] = 0.;
469 0 : fHadron[1][2] = 2.483298e-01;
470 0 : fHadron[1][3] = 0.;
471 0 : fHadron[1][4] = 0.;
472 :
473 0 : fHadron[2][0] = -5.601199e+00;
474 0 : fHadron[2][1] = 2.097382e+00;
475 0 : fHadron[2][2] = -2.307965e-01;
476 0 : fHadron[2][3] = 9.206871e-03;
477 0 : fHadron[2][4] = -8.887548e-05;
478 :
479 0 : fHadron[3][0] = 6.543101e+00;
480 0 : fHadron[3][1] = -2.305203e+00;
481 0 : fHadron[3][2] = 2.761673e-01;
482 0 : fHadron[3][3] = -5.465855e-03;
483 0 : fHadron[3][4] = 2.784329e-05;
484 :
485 0 : fHadron[4][0] = -2.443530e+01;
486 0 : fHadron[4][1] = 8.902578e+00 ;
487 0 : fHadron[4][2] = -5.265901e-01;
488 0 : fHadron[4][3] = 2.549111e-02;
489 0 : fHadron[4][4] = -2.196801e-04;
490 :
491 0 : fHadron[5][0] = 2.102007e-01;
492 0 : fHadron[5][1] = -3.844418e-02;
493 0 : fHadron[5][2] = 1.234682e-01;
494 0 : fHadron[5][3] = -3.866733e-03;
495 0 : fHadron[5][4] = 3.362719e-05 ;
496 :
497 0 : fPiZero[0][0] = 5.072157e-01;
498 0 : fPiZero[0][1] = -5.352747e-01;
499 0 : fPiZero[0][2] = 8.499259e-02;
500 0 : fPiZero[0][3] = -3.687401e-03;
501 0 : fPiZero[0][4] = 5.482280e-05;
502 :
503 0 : fPiZero[1][0] = 4.590137e+02;
504 0 : fPiZero[1][1] = -7.079341e+01;
505 0 : fPiZero[1][2] = 4.990735e+00;
506 0 : fPiZero[1][3] = -1.241302e-01;
507 0 : fPiZero[1][4] = 1.065772e-03;
508 :
509 0 : fPiZero[2][0] = 1.376415e+02;
510 0 : fPiZero[2][1] = -3.031577e+01;
511 0 : fPiZero[2][2] = 2.474338e+00;
512 0 : fPiZero[2][3] = -6.903410e-02;
513 0 : fPiZero[2][4] = 6.244089e-04;
514 :
515 0 : fPiZero[3][0] = 0.;
516 0 : fPiZero[3][1] = 1.145983e+00;
517 0 : fPiZero[3][2] = -2.476052e-01;
518 0 : fPiZero[3][3] = 1.367373e-02;
519 0 : fPiZero[3][4] = 0.;
520 :
521 0 : fPiZero[4][0] = -2.097586e+02;
522 0 : fPiZero[4][1] = 6.300800e+01;
523 0 : fPiZero[4][2] = -4.038906e+00;
524 0 : fPiZero[4][3] = 1.088543e-01;
525 0 : fPiZero[4][4] = -9.362485e-04;
526 :
527 0 : fPiZero[5][0] = -1.671477e+01;
528 0 : fPiZero[5][1] = 2.995415e+00;
529 0 : fPiZero[5][2] = -6.040360e-02;
530 0 : fPiZero[5][3] = -6.137459e-04;
531 0 : fPiZero[5][4] = 1.847328e-05;
532 :
533 0 : fHadronEnergyProb[0] = 4.767543e-02;
534 0 : fHadronEnergyProb[1] = -1.537523e+00;
535 0 : fHadronEnergyProb[2] = 2.956727e-01;
536 0 : fHadronEnergyProb[3] = -3.051022e+01;
537 0 : fHadronEnergyProb[4] = -6.036931e-02;
538 :
539 : // Int_t ii= 0;
540 : // Int_t jj= 3;
541 : // AliDebug(1,Form("PID parameters (%d, %d): fGamma=%.3f, fPi=%.3f, fHadron=%.3f",
542 : // ii,jj, fGamma[ii][jj],fPiZero[ii][jj],fHadron[ii][jj] ));
543 0 : }
544 :
545 : ///
546 : /// Set the default parameters for high multiplicity environment, Pb-Pb.
547 : ///
548 : //______________________________________________________________________________
549 : void AliEMCALPIDUtils::SetHighFluxParam()
550 : {
551 : // as a first step, all array elements are initialized to 0.0
552 : Int_t i=0, j=0;
553 120 : for (i = 0; i < 6; i++)
554 : {
555 672 : for (j = 0; j < 6; j++)
556 : {
557 288 : fGamma[i][j] = fHadron[i][j] = fPiZero[i][j] = 0.;
558 288 : fGamma1to10[i][j] = fHadron1to10[i][j] = 0.;
559 : }
560 48 : fGammaEnergyProb[i] = 0.;
561 48 : fPiZeroEnergyProb[i] = 0.;
562 48 : fHadronEnergyProb[i] = 0.;
563 : }
564 :
565 : // Pb-Pb this goes with inverted landau + gaussian for gammas, landau+gaussian for Pi0 and hadrons
566 :
567 8 : fGamma[0][0] = -7.656908e-01;
568 8 : fGamma[0][1] = 2.352536e-01;
569 8 : fGamma[0][2] = 1.555996e-02;
570 8 : fGamma[0][3] = 2.243525e-04;
571 8 : fGamma[0][4] = -2.560087e-06;
572 :
573 8 : fGamma[1][0] = 6.500216e+00;
574 8 : fGamma[1][1] = -2.564958e-01;
575 8 : fGamma[1][2] = 1.967894e-01;
576 8 : fGamma[1][3] = -3.982273e-04;
577 8 : fGamma[1][4] = 2.797737e-06;
578 :
579 8 : fGamma[2][0] = 2.416489e+00;
580 8 : fGamma[2][1] = -1.601258e-01;
581 8 : fGamma[2][2] = 3.126839e-02;
582 8 : fGamma[2][3] = 3.387532e-04;
583 8 : fGamma[2][4] = -4.089145e-06;
584 :
585 8 : fGamma[3][0] = 0.;
586 8 : fGamma[3][1] = -2.696008e+00;
587 8 : fGamma[3][2] = 6.920305e-01;
588 8 : fGamma[3][3] = -2.281122e-03;
589 8 : fGamma[3][4] = 0.;
590 :
591 8 : fGamma[4][0] = 2.281564e-01;
592 8 : fGamma[4][1] = -7.575040e-02;
593 8 : fGamma[4][2] = 3.813423e-01;
594 8 : fGamma[4][3] = -1.243854e-04;
595 8 : fGamma[4][4] = 1.232045e-06;
596 :
597 8 : fGamma[5][0] = -3.290107e-01;
598 8 : fGamma[5][1] = 3.707545e-02;
599 8 : fGamma[5][2] = 2.917397e-03;
600 8 : fGamma[5][3] = 4.695306e-05;
601 8 : fGamma[5][4] = -3.572981e-07;
602 :
603 8 : fHadron[0][0] = 1.519112e-01;
604 8 : fHadron[0][1] = -8.267603e-02;
605 8 : fHadron[0][2] = 1.914574e-02;
606 8 : fHadron[0][3] = -2.677921e-04;
607 8 : fHadron[0][4] = 5.447939e-06;
608 :
609 8 : fHadron[1][0] = 0.;
610 8 : fHadron[1][1] = -7.549870e-02;
611 8 : fHadron[1][2] = 3.930087e-01;
612 8 : fHadron[1][3] = -2.368500e-03;
613 8 : fHadron[1][4] = 0.;
614 :
615 8 : fHadron[2][0] = 0.;
616 8 : fHadron[2][1] = -2.463152e-02;
617 8 : fHadron[2][2] = 1.349257e-01;
618 8 : fHadron[2][3] = -1.089440e-03;
619 8 : fHadron[2][4] = 0.;
620 :
621 8 : fHadron[3][0] = 0.;
622 8 : fHadron[3][1] = 5.101560e-01;
623 8 : fHadron[3][2] = 1.458679e-01;
624 8 : fHadron[3][3] = 4.903068e-04;
625 8 : fHadron[3][4] = 0.;
626 :
627 8 : fHadron[4][0] = 0.;
628 8 : fHadron[4][1] = -6.693943e-03;
629 8 : fHadron[4][2] = 2.444753e-01;
630 8 : fHadron[4][3] = -5.553749e-05;
631 8 : fHadron[4][4] = 0.;
632 :
633 8 : fHadron[5][0] = -4.414030e-01;
634 8 : fHadron[5][1] = 2.292277e-01;
635 8 : fHadron[5][2] = -2.433737e-02;
636 8 : fHadron[5][3] = 1.758422e-03;
637 8 : fHadron[5][4] = -3.001493e-05;
638 :
639 8 : fPiZero[0][0] = 5.072157e-01;
640 8 : fPiZero[0][1] = -5.352747e-01;
641 8 : fPiZero[0][2] = 8.499259e-02;
642 8 : fPiZero[0][3] = -3.687401e-03;
643 8 : fPiZero[0][4] = 5.482280e-05;
644 :
645 8 : fPiZero[1][0] = 4.590137e+02;
646 8 : fPiZero[1][1] = -7.079341e+01;
647 8 : fPiZero[1][2] = 4.990735e+00;
648 8 : fPiZero[1][3] = -1.241302e-01;
649 8 : fPiZero[1][4] = 1.065772e-03;
650 :
651 8 : fPiZero[2][0] = 1.376415e+02;
652 8 : fPiZero[2][1] = -3.031577e+01;
653 8 : fPiZero[2][2] = 2.474338e+00;
654 8 : fPiZero[2][3] = -6.903410e-02;
655 8 : fPiZero[2][4] = 6.244089e-04;
656 :
657 8 : fPiZero[3][0] = 0.;
658 8 : fPiZero[3][1] = 1.145983e+00;
659 8 : fPiZero[3][2] = -2.476052e-01;
660 8 : fPiZero[3][3] = 1.367373e-02;
661 8 : fPiZero[3][4] = 0.;
662 :
663 8 : fPiZero[4][0] = -2.097586e+02;
664 8 : fPiZero[4][1] = 6.300800e+01;
665 8 : fPiZero[4][2] = -4.038906e+00;
666 8 : fPiZero[4][3] = 1.088543e-01;
667 8 : fPiZero[4][4] = -9.362485e-04;
668 :
669 8 : fPiZero[5][0] = -1.671477e+01;
670 8 : fPiZero[5][1] = 2.995415e+00;
671 8 : fPiZero[5][2] = -6.040360e-02;
672 8 : fPiZero[5][3] = -6.137459e-04;
673 8 : fPiZero[5][4] = 1.847328e-05;
674 :
675 : // those are the High Flux PbPb ones
676 8 : fHadronEnergyProb[0] = 0.;
677 8 : fHadronEnergyProb[1] = 0.;
678 8 : fHadronEnergyProb[2] = 6.188452e-02;
679 8 : fHadronEnergyProb[3] = 2.030230e+00;
680 8 : fHadronEnergyProb[4] = -6.402242e-02;
681 :
682 : // Int_t ii= 0;
683 : // Int_t jj= 3;
684 : // AliDebug(1,Form("PID parameters (%d, %d): fGamma=%.3f, fPi=%.3f, fHadron=%.3f",
685 : // ii,jj, fGamma[ii][jj],fPiZero[ii][jj],fHadron[ii][jj] ));
686 8 : }
687 :
|
