MCEvent and MCEventHandler can be used as containers. This allows us to compose MC...
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALRecParam.cxx
CommitLineData
3a8be91c 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/* $Id$ */
17// --- AliRoot header files ---
feedcab9 18#include "TObjArray.h"
19#include "AliCDBManager.h"
20#include "AliCDBEntry.h"
3a8be91c 21#include "AliEMCALRecParam.h"
22#include "AliLog.h"
23
24ClassImp(AliEMCALRecParam)
25
feedcab9 26TObjArray* AliEMCALRecParam::fgkMaps =0; //ALTRO mappings
27
3a8be91c 28//-----------------------------------------------------------------------------
29// Container of EMCAL reconstruction parameters
30// The purpose of this object is to store it to OCDB
31// and retrieve it in AliEMCALClusterizerv1
32// Author: Yuri Kharlov
33//-----------------------------------------------------------------------------
34
413e6b81 35AliEMCALRecParam::AliEMCALRecParam() :
36 AliDetectorRecoParam(),
37 fClusteringThreshold(0.5),
38 fW0(4.5),
39 fMinECut(0.45),
40 fUnfold(kFALSE),
41 fLocMaxCut(0.03), //clustering
42 fTrkCutX(6.0),
43 fTrkCutY(6.0),
44 fTrkCutZ(6.0),
45 fTrkCutR(10.0),
46 fTrkCutAlphaMin(-50.0),
47 fTrkCutAlphaMax(50.0),
dcd86c5d 48 fTrkCutAngle(10000.0),
49 fTrkCutNITS(3.0),
50 fTrkCutNTPC(20.0), //track matching
413e6b81 51 fHighLowGainFactor(16.0),
52 fOrderParameter(2),
53 fTau(2.35),
54 fNoiseThreshold(3),
55 fNPedSamples(5) //raw signal
c47157cd 56{
57 // default reco values
8ba062b1 58
59 //PID parameters (Guenole)
60
61 // as a first step, all array elements are initialized to 0.0
62 Int_t i, j;
63 for (i = 0; i < 6; i++) {
64 for (j = 0; j < 6; j++) {
65 fGamma[i][j] = fHadron[i][j] = fPiZero5to10[i][j] = fPiZero10to60[i][j] = 0.;
66 }
67 }
68
69 // then, only the ones which must be not zero are initialized
70 // while the others will remain to the value 0.0
71
72 fGamma[0][0] = 0.038022;
73 fGamma[0][1] = -0.0001883;
74 fGamma[0][2] = 5.449e-06;
75
76 fGamma[1][0] = 0.207313;
77 fGamma[1][1] = -0.000978;
78 fGamma[1][2] = 0.00001634;
79
80 fGamma[2][0] = 0.043364;
81 fGamma[2][1] = -0.0002048;
82 fGamma[2][2] = 8.661e-06;
83 fGamma[2][3] = -1.353e-07;
84
85 fGamma[3][0] = 0.265004;
86 fGamma[3][1] = 0.061298;
87 fGamma[3][2] = -0.003203;
88 fGamma[3][3] = 4.73e-05;
89
90 fGamma[4][0] = 0.243579;
91 fGamma[4][1] = -1.614e-05;
92
93 fGamma[5][0] = 0.002942;
94 fGamma[5][1] = -3.976e-05;
95
96 fHadron[0][0] = 0.011945 / 3.;
97 fHadron[0][1] = 0.000386 / 3.;
98 fHadron[0][2] = -0.000014 / 3.;
99 fHadron[0][3] = 1.336e-07 / 3.;
100
101 fHadron[1][0] = 0.496544;
102 fHadron[1][1] = -0.003226;
103 fHadron[1][2] = 0.00001678;
104
105 fHadron[2][0] = 0.144838;
106 fHadron[2][1] = -0.002954;
107 fHadron[2][2] = 0.00008754;
108 fHadron[2][3] = -7.587e-07;
109
110 fHadron[3][0] = 1.264461 / 7.;
111 fHadron[3][1] = 0.002097 / 7.;
112
113 fHadron[4][0] = 0.261950;
114 fHadron[4][1] = -0.001078;
115 fHadron[4][2] = 0.00003237;
116 fHadron[4][3] = -3.241e-07;
117 fHadron[4][4] = 0.;
118 fHadron[4][5] = 0.;
119 fHadron[5][0] = 0.010317;
120 fHadron[5][1] = 0.;
121 fHadron[5][2] = 0.;
122 fHadron[5][3] = 0.;
123 fHadron[5][4] = 0.;
124 fHadron[5][5] = 0.;
125
126 fPiZero5to10[0][0] = 0.009138;
127 fPiZero5to10[0][1] = 0.0006377;
128
129 fPiZero5to10[1][0] = 0.08;
130
131 fPiZero5to10[2][0] = -0.061119;
132 fPiZero5to10[2][1] = 0.019013;
133
134 fPiZero5to10[3][0] = 0.2;
135
136 fPiZero5to10[4][0] = 0.252044;
137 fPiZero5to10[4][1] = -0.002315;
138
139 fPiZero5to10[5][0] = 0.002942;
140 fPiZero5to10[5][1] = -3.976e-05;
141
142 fPiZero10to60[0][0] = 0.009138;
143 fPiZero10to60[0][1] = 0.0006377;
144
145 fPiZero10to60[1][0] = 1.272837;
146 fPiZero10to60[1][1] = -0.069708;
147 fPiZero10to60[1][2] = 0.001568;
148 fPiZero10to60[1][3] = -1.162e-05;
149
150 fPiZero10to60[2][0] = 0.139703;
151 fPiZero10to60[2][1] = 0.003687;
152 fPiZero10to60[2][2] = -0.000568;
153 fPiZero10to60[2][3] = 1.498e-05;
154 fPiZero10to60[2][4] = -1.174e-07;
155
156 fPiZero10to60[3][0] = -0.826367;
157 fPiZero10to60[3][1] = 0.096951;
158 fPiZero10to60[3][2] = -0.002215;
159 fPiZero10to60[3][3] = 2.523e-05;
160
161 fPiZero10to60[4][0] = 0.249890;
162 fPiZero10to60[4][1] = -0.000063;
163
164 fPiZero10to60[5][0] = 0.002942;
165 fPiZero10to60[5][1] = -3.976e-05;
166
c47157cd 167}
3a8be91c 168
169//-----------------------------------------------------------------------------
413e6b81 170AliEMCALRecParam::AliEMCALRecParam(const AliEMCALRecParam& rp) :
171 AliDetectorRecoParam(),
172 fClusteringThreshold(rp.fClusteringThreshold),
173 fW0(rp.fW0),
174 fMinECut(rp.fMinECut),
175 fUnfold(rp.fUnfold),
176 fLocMaxCut(rp.fLocMaxCut), //clustering
177 fTrkCutX(rp.fTrkCutX),
178 fTrkCutY(rp.fTrkCutY),
179 fTrkCutZ(rp.fTrkCutZ),
180 fTrkCutR(rp.fTrkCutR),
181 fTrkCutAlphaMin(rp.fTrkCutAlphaMin),
182 fTrkCutAlphaMax(rp.fTrkCutAlphaMax),
dcd86c5d 183 fTrkCutAngle(rp.fTrkCutAngle),
184 fTrkCutNITS(rp.fTrkCutNITS),
185 fTrkCutNTPC(rp.fTrkCutNTPC), // track matching
413e6b81 186 fHighLowGainFactor(rp.fHighLowGainFactor),
187 fOrderParameter(rp.fOrderParameter),
188 fTau(rp.fTau),
189 fNoiseThreshold(rp.fNoiseThreshold),
190 fNPedSamples(rp.fNPedSamples) //raw signal
191{
192 //copy constructor
193
194 //PID values
195 Int_t i, j;
196 for (i = 0; i < 6; i++) {
197 for (j = 0; j < 6; j++) {
198 fGamma[i][j] = rp.fGamma[i][j];
199 fHadron[i][j] = rp.fHadron[i][j];
200 fPiZero5to10[i][j] = rp.fPiZero5to10[i][j];
201 fPiZero10to60[i][j] = rp.fPiZero10to60[i][j];
202 }
203 }
204
205}
206
207//-----------------------------------------------------------------------------
208AliEMCALRecParam& AliEMCALRecParam::operator = (const AliEMCALRecParam& rp)
209{
210 //assignment operator
211
212 if(this != &rp) {
213 fClusteringThreshold = rp.fClusteringThreshold;
214 fW0 = rp.fW0;
215 fMinECut = rp.fMinECut;
216 fUnfold = rp.fUnfold;
217 fLocMaxCut = rp.fLocMaxCut; //clustering
218 fTrkCutX = rp.fTrkCutX;
219 fTrkCutY = rp.fTrkCutY;
220 fTrkCutZ = rp.fTrkCutZ;
221 fTrkCutR = rp.fTrkCutR;
222 fTrkCutAlphaMin = rp.fTrkCutAlphaMin;
223 fTrkCutAlphaMax = rp.fTrkCutAlphaMax;
dcd86c5d 224 fTrkCutAngle = rp.fTrkCutAngle;
225 fTrkCutNITS = rp.fTrkCutNITS;
226 fTrkCutNTPC = rp.fTrkCutNTPC; //track matching
413e6b81 227 fHighLowGainFactor = rp.fHighLowGainFactor;
228 fOrderParameter = rp.fOrderParameter;
229 fTau = rp.fTau;
230 fNoiseThreshold = rp.fNoiseThreshold;
231 fNPedSamples = rp.fNPedSamples; //raw signal
232
233 //PID values
234 Int_t i, j;
235 for (i = 0; i < 6; i++) {
236 for (j = 0; j < 6; j++) {
237 fGamma[i][j] = rp.fGamma[i][j];
238 fHadron[i][j] = rp.fHadron[i][j];
239 fPiZero5to10[i][j] = rp.fPiZero5to10[i][j];
240 fPiZero10to60[i][j] = rp.fPiZero10to60[i][j];
241 }
242 }
243
244 }
245
246 return *this;
247
248}
249
250//-----------------------------------------------------------------------------
251AliEMCALRecParam* AliEMCALRecParam::GetDefaultParameters()
252{
253 //default parameters for the reconstruction
254 AliEMCALRecParam* params = new AliEMCALRecParam();
f5fc991a 255 params->SetName("Default - Pb+Pb");
256 params->SetTitle("Default - Pb+Pb");
257 return params;
258
259}
260
98cf874d 261//-----------------------------------------------------------------------------
262AliEMCALRecParam* AliEMCALRecParam::GetCalibParam()
263{
264 //parameters for the reconstruction of calibration runs
265 AliEMCALRecParam* params = new AliEMCALRecParam();
266 params->SetClusteringThreshold(0.2); // 200 MeV
267 params->SetMinECut(0.01); //10 MeV
268 params->SetName("Calibration - LED");
269 params->SetTitle("Calibration - LED");
270 params->SetEventSpecie(AliRecoParam::kCalib);
271
272 return params;
273
274}
275
276//-----------------------------------------------------------------------------
277AliEMCALRecParam* AliEMCALRecParam::GetCosmicParam()
278{
279 //parameters for the reconstruction of cosmic runs
280 AliEMCALRecParam* params = new AliEMCALRecParam();
281 params->SetClusteringThreshold(0.2); // 200 MeV
282 params->SetMinECut(0.01); //10 MeV
283 params->SetName("Cosmic");
284 params->SetTitle("Cosmic");
285 params->SetEventSpecie(AliRecoParam::kCosmic);
286
287 return params;
288
289}
f5fc991a 290
291//-----------------------------------------------------------------------------
292AliEMCALRecParam* AliEMCALRecParam::GetLowFluxParam()
293{
294 //low flux/multiplicity ("p+p") parameters for the reconstruction
295 AliEMCALRecParam* params = new AliEMCALRecParam();
50c386d5 296 params->SetClusteringThreshold(0.2); // 200 MeV
f5fc991a 297 params->SetMinECut(0.01); //10 MeV
298 params->SetName("Low Flux - p+p");
299 params->SetTitle("Low Flux - p+p");
300 params->SetEventSpecie(AliRecoParam::kLowMult);
301
302 return params;
303
304}
305
306
307//-----------------------------------------------------------------------------
308AliEMCALRecParam* AliEMCALRecParam::GetHighFluxParam()
309{
310 //high flux/multiplicity ("Pb+Pb") parameters for the reconstruction
311 AliEMCALRecParam* params = new AliEMCALRecParam();
312 //For now, same as default
313 //if later these need to be modified, here's where it is done
314 params->SetName("High Flux - Pb+Pb");
315 params->SetTitle("High Flux - Pb+Pb");
316 params->SetEventSpecie(AliRecoParam::kHighMult);
317
413e6b81 318 return params;
319
320}
321
322//-----------------------------------------------------------------------------
3a8be91c 323void AliEMCALRecParam::Print(Option_t *) const
324{
3a8be91c 325 // Print reconstruction parameters to stdout
225cd96d 326 AliInfo(Form("Clusterization parameters :\n fClusteringThreshold=%.3f,\n fW0=%.3f,\n fMinECut=%.3f,\n fUnfold=%d,\n fLocMaxCut=%.3f \n",
327 fClusteringThreshold,fW0,fMinECut,fUnfold,fLocMaxCut));
3a8be91c 328
dcd86c5d 329 AliInfo(Form("Track-matching cuts :\n x %f, y %f, z %f, R %f \n alphaMin %f, alphaMax %f, Angle %f, NITS %f, NTPC %f\n", fTrkCutX, fTrkCutY, fTrkCutZ, fTrkCutR,fTrkCutAlphaMin,fTrkCutAlphaMax, fTrkCutAngle,fTrkCutNITS,fTrkCutNTPC));
8ba062b1 330
331 AliInfo(Form("PID parameters, Gamma :\n"));
332 for(Int_t i = 0; i < 6; i++){
333 for(Int_t j = 0; j < 6; j++){
334 printf(" %f, ", fGamma[i][j]);
335 }
336 printf("\n");
337 }
338
339 printf("\n");
340
341 AliInfo(Form("PID parameters, Hadron :\n"));
342 for(Int_t i = 0; i < 6; i++){
343 for(Int_t j = 0; j < 6; j++){
344 printf(" %f, ", fHadron[i][j]);
345 }
346 printf("\n");
347 }
348
349 printf("\n");
350
351 AliInfo(Form("PID parameters, Pi0zero5to10 :\n"));
352 for(Int_t i = 0; i < 6; i++){
353 for(Int_t j = 0; j < 6; j++){
354 printf(" %f, ", fPiZero5to10[i][j]);
355 }
356 printf("\n");
357 }
358
359 printf("\n");
360
361 AliInfo(Form("PID parameters, Pi0zero10to60 :\n"));
362 for(Int_t i = 0; i < 6; i++){
363 for(Int_t j = 0; j < 6; j++){
364 printf(" %f, ", fPiZero10to60[i][j]);
365 }
366 printf("\n");
367 }
368
369 printf("\n");
370
b4133f05 371 AliInfo(Form("Raw signal parameters: \n gain factor=%f, order=%d, tau=%f, noise threshold=%d, nped samples=%d \n",
372 fHighLowGainFactor,fOrderParameter,fTau,fNoiseThreshold,fNPedSamples));
373
3a8be91c 374}
8ba062b1 375
413e6b81 376//-----------------------------------------------------------------------------
feedcab9 377const TObjArray* AliEMCALRecParam::GetMappings()
378{
413e6b81 379 //Returns array of AliAltroMappings for RCU0..RCUX.
380 //If not found, read it from OCDB.
381
382 //Quick check as follows:
162637e4 383 // root [0] AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB"
413e6b81 384 // root [1] AliCDBManager::Instance()->SetRun(1);
385 // root [2] TObjArray* maps = AliEMCALRecParam::GetMappings();
386 // root [3] maps->Print();
feedcab9 387
388 if(fgkMaps) return fgkMaps;
389
390 AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/Mapping");
391 if(entry)
392 fgkMaps = (TObjArray*)entry->GetObject();
393
394 return fgkMaps;
395
396}
397