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