]>
Commit | Line | Data |
---|---|---|
1 | /************************************************************************** | |
2 | * Copyright(c) 1998-2008, 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 | //***************************************************** | |
17 | // Class AliCentralitySelectionTask | |
18 | // Class to analyze determine centrality | |
19 | // author: Alberica Toia | |
20 | //***************************************************** | |
21 | ||
22 | #include "AliCentralitySelectionTask.h" | |
23 | ||
24 | #include <TTree.h> | |
25 | #include <TList.h> | |
26 | #include <TH1F.h> | |
27 | #include <TH2F.h> | |
28 | #include <TProfile.h> | |
29 | #include <TFile.h> | |
30 | #include <TObjString.h> | |
31 | #include <TString.h> | |
32 | #include <TCanvas.h> | |
33 | #include <TROOT.h> | |
34 | #include <TDirectory.h> | |
35 | #include <TSystem.h> | |
36 | #include <iostream> | |
37 | ||
38 | #include "AliAnalysisManager.h" | |
39 | #include "AliVEvent.h" | |
40 | #include "AliESD.h" | |
41 | #include "AliESDEvent.h" | |
42 | #include "AliESDHeader.h" | |
43 | #include "AliESDInputHandler.h" | |
44 | #include "AliESDZDC.h" | |
45 | #include "AliESDFMD.h" | |
46 | #include "AliESDVZERO.h" | |
47 | #include "AliCentrality.h" | |
48 | #include "AliESDtrackCuts.h" | |
49 | #include "AliMultiplicity.h" | |
50 | #include "AliAODHandler.h" | |
51 | #include "AliAODEvent.h" | |
52 | #include "AliESDVertex.h" | |
53 | #include "AliAODVertex.h" | |
54 | #include "AliAODMCHeader.h" | |
55 | #include "AliMCEvent.h" | |
56 | #include "AliMCEventHandler.h" | |
57 | #include "AliMCParticle.h" | |
58 | #include "AliStack.h" | |
59 | #include "AliHeader.h" | |
60 | #include "AliAODMCParticle.h" | |
61 | #include "AliAnalysisTaskSE.h" | |
62 | #include "AliGenEventHeader.h" | |
63 | #include "AliGenHijingEventHeader.h" | |
64 | #include "AliPhysicsSelectionTask.h" | |
65 | #include "AliPhysicsSelection.h" | |
66 | #include "AliBackgroundSelection.h" | |
67 | #include "AliESDUtils.h" | |
68 | ||
69 | ClassImp(AliCentralitySelectionTask) | |
70 | ||
71 | ||
72 | //________________________________________________________________________ | |
73 | AliCentralitySelectionTask::AliCentralitySelectionTask(): | |
74 | AliAnalysisTaskSE(), | |
75 | fDebug(0), | |
76 | fAnalysisInput("ESD"), | |
77 | fIsMCInput(kFALSE), | |
78 | fDirName("$ALICE_ROOT/OADB/COMMON/CENTRALITY/data"), | |
79 | fFile(0), | |
80 | fFile2(0), | |
81 | fCurrentRun(-1), | |
82 | fRunNo(-1), | |
83 | fTrackCuts(0), | |
84 | fCentV0M(0), | |
85 | fCentFMD(0), | |
86 | fCentTRK(0), | |
87 | fCentTKL(0), | |
88 | fCentCL0(0), | |
89 | fCentCL1(0), | |
90 | fCentV0MvsFMD(0), | |
91 | fCentTKLvsV0M(0), | |
92 | fCentZEMvsZDC(0), | |
93 | fHtempV0M(0), | |
94 | fHtempFMD(0), | |
95 | fHtempTRK(0), | |
96 | fHtempTKL(0), | |
97 | fHtempCL0(0), | |
98 | fHtempCL1(0), | |
99 | fHtempV0MvsFMD(0), | |
100 | fHtempTKLvsV0M(0), | |
101 | fHtempZEMvsZDC(0), | |
102 | fOutputList(0), | |
103 | fHOutCentV0M (0), | |
104 | fHOutCentFMD (0), | |
105 | fHOutCentTRK (0), | |
106 | fHOutCentTKL (0), | |
107 | fHOutCentCL0 (0), | |
108 | fHOutCentCL1 (0), | |
109 | fHOutCentV0MvsFMD(0), | |
110 | fHOutCentTKLvsV0M(0), | |
111 | fHOutCentZEMvsZDC(0), | |
112 | fHOutMultV0M(0), | |
113 | fHOutMultV0R(0), | |
114 | fHOutMultFMD(0), | |
115 | fHOutMultTRK(0), | |
116 | fHOutMultTKL(0), | |
117 | fHOutMultCL0(0), | |
118 | fHOutMultCL1(0), | |
119 | fHOutMultV0MvsZDC(0), | |
120 | fHOutMultZEMvsZDC(0), | |
121 | fHOutMultV0MvsCL1(0), | |
122 | fHOutMultV0MvsTRK(0), | |
123 | fHOutMultTRKvsCL1(0) | |
124 | { | |
125 | // Default constructor | |
126 | AliInfo("Centrality Selection enabled."); | |
127 | } | |
128 | ||
129 | //________________________________________________________________________ | |
130 | AliCentralitySelectionTask::AliCentralitySelectionTask(const char *name): | |
131 | AliAnalysisTaskSE(name), | |
132 | fDebug(0), | |
133 | fAnalysisInput("ESD"), | |
134 | fIsMCInput(kFALSE), | |
135 | fDirName("$ALICE_ROOT/OADB/COMMON/CENTRALITY/data"), | |
136 | fFile(0), | |
137 | fFile2(0), | |
138 | fCurrentRun(-1), | |
139 | fRunNo(-1), | |
140 | fTrackCuts(0), | |
141 | fCentV0M(0), | |
142 | fCentFMD(0), | |
143 | fCentTRK(0), | |
144 | fCentTKL(0), | |
145 | fCentCL0(0), | |
146 | fCentCL1(0), | |
147 | fCentV0MvsFMD(0), | |
148 | fCentTKLvsV0M(0), | |
149 | fCentZEMvsZDC(0), | |
150 | fHtempV0M(0), | |
151 | fHtempFMD(0), | |
152 | fHtempTRK(0), | |
153 | fHtempTKL(0), | |
154 | fHtempCL0(0), | |
155 | fHtempCL1(0), | |
156 | fHtempV0MvsFMD(0), | |
157 | fHtempTKLvsV0M(0), | |
158 | fHtempZEMvsZDC(0), | |
159 | fOutputList(0), | |
160 | fHOutCentV0M (0), | |
161 | fHOutCentFMD (0), | |
162 | fHOutCentTRK (0), | |
163 | fHOutCentTKL (0), | |
164 | fHOutCentCL0 (0), | |
165 | fHOutCentCL1 (0), | |
166 | fHOutCentV0MvsFMD(0), | |
167 | fHOutCentTKLvsV0M(0), | |
168 | fHOutCentZEMvsZDC(0), | |
169 | fHOutMultV0M(0), | |
170 | fHOutMultV0R(0), | |
171 | fHOutMultFMD(0), | |
172 | fHOutMultTRK(0), | |
173 | fHOutMultTKL(0), | |
174 | fHOutMultCL0(0), | |
175 | fHOutMultCL1(0), | |
176 | fHOutMultV0MvsZDC(0), | |
177 | fHOutMultZEMvsZDC(0), | |
178 | fHOutMultV0MvsCL1(0), | |
179 | fHOutMultV0MvsTRK(0), | |
180 | fHOutMultTRKvsCL1(0) | |
181 | { | |
182 | // Default constructor | |
183 | AliInfo("Centrality Selection enabled."); | |
184 | DefineOutput(1, TList::Class()); | |
185 | } | |
186 | ||
187 | //________________________________________________________________________ | |
188 | AliCentralitySelectionTask& AliCentralitySelectionTask::operator=(const AliCentralitySelectionTask& c) | |
189 | { | |
190 | // Assignment operator | |
191 | if (this!=&c) { | |
192 | AliAnalysisTaskSE::operator=(c); | |
193 | } | |
194 | return *this; | |
195 | } | |
196 | ||
197 | //________________________________________________________________________ | |
198 | AliCentralitySelectionTask::AliCentralitySelectionTask(const AliCentralitySelectionTask& ana): | |
199 | AliAnalysisTaskSE(ana), | |
200 | fDebug(ana.fDebug), | |
201 | fAnalysisInput(ana.fDebug), | |
202 | fIsMCInput(ana.fIsMCInput), | |
203 | fDirName(ana.fDirName), | |
204 | fFile(ana.fFile), | |
205 | fFile2(ana.fFile2), | |
206 | fCurrentRun(ana.fCurrentRun), | |
207 | fRunNo(ana.fRunNo), | |
208 | fTrackCuts(ana.fTrackCuts), | |
209 | fCentV0M(ana.fCentV0M), | |
210 | fCentFMD(ana.fCentFMD), | |
211 | fCentTRK(ana.fCentTRK), | |
212 | fCentTKL(ana.fCentTKL), | |
213 | fCentCL0(ana.fCentCL0), | |
214 | fCentCL1(ana.fCentCL1), | |
215 | fCentV0MvsFMD(ana.fCentV0MvsFMD), | |
216 | fCentTKLvsV0M(ana.fCentTKLvsV0M), | |
217 | fCentZEMvsZDC(ana.fCentZEMvsZDC), | |
218 | fHtempV0M(ana.fHtempV0M), | |
219 | fHtempFMD(ana.fHtempFMD), | |
220 | fHtempTRK(ana.fHtempTRK), | |
221 | fHtempTKL(ana.fHtempTKL), | |
222 | fHtempCL0(ana.fHtempCL0), | |
223 | fHtempCL1(ana.fHtempCL1), | |
224 | fHtempV0MvsFMD(ana.fHtempV0MvsFMD), | |
225 | fHtempTKLvsV0M(ana.fHtempTKLvsV0M), | |
226 | fHtempZEMvsZDC(ana.fHtempZEMvsZDC), | |
227 | fOutputList(ana.fOutputList), | |
228 | fHOutCentV0M (ana.fHOutCentV0M ), | |
229 | fHOutCentFMD (ana.fHOutCentFMD ), | |
230 | fHOutCentTRK (ana.fHOutCentTRK ), | |
231 | fHOutCentTKL (ana.fHOutCentTKL ), | |
232 | fHOutCentCL0 (ana.fHOutCentCL0 ), | |
233 | fHOutCentCL1 (ana.fHOutCentCL1 ), | |
234 | fHOutCentV0MvsFMD(ana.fHOutCentV0MvsFMD), | |
235 | fHOutCentTKLvsV0M(ana.fHOutCentTKLvsV0M), | |
236 | fHOutCentZEMvsZDC(ana.fHOutCentZEMvsZDC), | |
237 | fHOutMultV0M(ana.fHOutMultV0M), | |
238 | fHOutMultV0R(ana.fHOutMultV0R), | |
239 | fHOutMultFMD(ana.fHOutMultFMD), | |
240 | fHOutMultTRK(ana.fHOutMultTRK), | |
241 | fHOutMultTKL(ana.fHOutMultTKL), | |
242 | fHOutMultCL0(ana.fHOutMultCL0), | |
243 | fHOutMultCL1(ana.fHOutMultCL1), | |
244 | fHOutMultV0MvsZDC(ana.fHOutMultV0MvsZDC), | |
245 | fHOutMultZEMvsZDC(ana.fHOutMultZEMvsZDC), | |
246 | fHOutMultV0MvsCL1(ana.fHOutMultV0MvsCL1), | |
247 | fHOutMultV0MvsTRK(ana.fHOutMultV0MvsTRK), | |
248 | fHOutMultTRKvsCL1(ana.fHOutMultTRKvsCL1) | |
249 | { | |
250 | // Copy Constructor | |
251 | } | |
252 | ||
253 | //________________________________________________________________________ | |
254 | AliCentralitySelectionTask::~AliCentralitySelectionTask() | |
255 | { | |
256 | // Destructor | |
257 | if (fOutputList && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) delete fOutputList; | |
258 | if (fTrackCuts) delete fTrackCuts; | |
259 | } | |
260 | ||
261 | //________________________________________________________________________ | |
262 | void AliCentralitySelectionTask::UserCreateOutputObjects() | |
263 | { | |
264 | // Create the output containers | |
265 | if(fDebug>1) printf("AnalysisCentralitySelectionTask::UserCreateOutputObjects() \n"); | |
266 | AliLog::SetClassDebugLevel("AliCentralitySelectionTask", AliLog::kInfo); | |
267 | ||
268 | fOutputList = new TList(); | |
269 | fOutputList->SetOwner(); | |
270 | fHOutCentV0M = new TH1F("fHOutCentV0M","fHOutCentV0M; Centrality V0",101,-0.5,100.5); | |
271 | fHOutCentFMD = new TH1F("fHOutCentFMD","fHOutCentFMD; Centrality FMD",101,-0.5,100.5); | |
272 | fHOutCentTRK = new TH1F("fHOutCentTRK","fHOutCentTRK; Centrality TPC",101,-0.5,100.5); | |
273 | fHOutCentTKL = new TH1F("fHOutCentTKL","fHOutCentTKL; Centrality tracklets",101,-0.5,100.5); | |
274 | fHOutCentCL0 = new TH1F("fHOutCentCL0","fHOutCentCL0; Centrality SPD inner",101,-0.5,100.5); | |
275 | fHOutCentCL1 = new TH1F("fHOutCentCL1","fHOutCentCL1; Centrality SPD outer",101,-0.5,100.5); | |
276 | fHOutCentV0MvsFMD= new TH1F("fHOutCentV0MvsFMD","fHOutCentV0MvsFMD; Centrality V0 vs FMD",101,-0.5,100.5); | |
277 | fHOutCentTKLvsV0M= new TH1F("fHOutCentTKLvsV0M","fHOutCentTKLvsV0M; Centrality tracklets vs V0",101,-0.5,100.5); | |
278 | fHOutCentZEMvsZDC= new TH1F("fHOutCentZEMvsZDC","fHOutCentZEMvsZDC; Centrality ZEM vs ZDC",101,-0.5,100.5); | |
279 | ||
280 | fHOutMultV0M = new TH1F("fHOutMultV0M","fHOutMultV0M; Multiplicity V0",25000,0,25000); | |
281 | fHOutMultV0R = new TH1F("fHOutMultV0R","fHOutMultV0R; Multiplicity V0",25000,0,25000); | |
282 | fHOutMultFMD = new TH1F("fHOutMultFMD","fHOutMultFMD; Multiplicity FMD",24000,0,24000); | |
283 | fHOutMultTRK = new TH1F("fHOutMultTRK","fHOutMultTRK; Multiplicity TPC",4000,0,4000); | |
284 | fHOutMultTKL = new TH1F("fHOutMultTKL","fHOutMultTKL; Multiplicity tracklets",5000,0,5000); | |
285 | fHOutMultCL0 = new TH1F("fHOutMultCL0","fHOutMultCL0; Multiplicity SPD inner",7000,0,7000); | |
286 | fHOutMultCL1 = new TH1F("fHOutMultCL1","fHOutMultCL1; Multiplicity SPD outer",7000,0,7000); | |
287 | fHOutMultV0MvsZDC = new TH2F("fHOutMultV0MvsZDC","fHOutMultV0MvsZDC; Multiplicity V0; Energy ZDC",500,0,25000,500,0,6000); | |
288 | fHOutMultZEMvsZDC = new TH2F("fHOutMultZEMvsZDC","fHOutMultZEMvsZDC; Energy ZEM; Energy ZDC",500,0,2500,500,0,6000); | |
289 | fHOutMultV0MvsCL1 = new TH2F("fHOutMultV0MvsCL1","fHOutMultV0MvsCL1; Multiplicity V0; Multiplicity SPD outer",2500,0,25000,700,0,7000); | |
290 | fHOutMultV0MvsTRK = new TH2F("fHOutMultV0MvsTRK","fHOutMultV0MvsTRK; Multiplicity V0; Multiplicity TPC",2500,0,25000,400,0,4000); | |
291 | fHOutMultTRKvsCL1 = new TH2F("fHOutMultTRKvsCL1","fHOutMultTRKvsCL1; Multiplicity TPC; Multiplicity SPD outer",400,0,4000,700,0,7000); | |
292 | ||
293 | fOutputList->Add( fHOutCentV0M ); | |
294 | fOutputList->Add( fHOutCentFMD ); | |
295 | fOutputList->Add( fHOutCentTRK ); | |
296 | fOutputList->Add( fHOutCentTKL ); | |
297 | fOutputList->Add( fHOutCentCL0 ); | |
298 | fOutputList->Add( fHOutCentCL1 ); | |
299 | fOutputList->Add( fHOutCentV0MvsFMD); | |
300 | fOutputList->Add( fHOutCentTKLvsV0M); | |
301 | fOutputList->Add( fHOutCentZEMvsZDC); | |
302 | fOutputList->Add( fHOutMultV0M); | |
303 | fOutputList->Add( fHOutMultV0R); | |
304 | fOutputList->Add( fHOutMultFMD); | |
305 | fOutputList->Add( fHOutMultTRK); | |
306 | fOutputList->Add( fHOutMultTKL); | |
307 | fOutputList->Add( fHOutMultCL0); | |
308 | fOutputList->Add( fHOutMultCL1); | |
309 | fOutputList->Add( fHOutMultV0MvsZDC); | |
310 | fOutputList->Add( fHOutMultZEMvsZDC); | |
311 | fOutputList->Add( fHOutMultV0MvsCL1); | |
312 | fOutputList->Add( fHOutMultV0MvsTRK); | |
313 | fOutputList->Add( fHOutMultTRKvsCL1); | |
314 | ||
315 | ||
316 | fTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts(); | |
317 | ||
318 | PostData(1, fOutputList); | |
319 | } | |
320 | ||
321 | //________________________________________________________________________ | |
322 | void AliCentralitySelectionTask::UserExec(Option_t */*option*/) | |
323 | { | |
324 | // Execute analysis for current event: | |
325 | if(fDebug>1) printf(" **** AliCentralitySelectionTask::UserExec() \n"); | |
326 | ||
327 | Float_t zncEnergy = 0.; // ZNC Energy | |
328 | Float_t zpcEnergy = 0.; // ZPC Energy | |
329 | Float_t znaEnergy = 0.; // ZNA Energy | |
330 | Float_t zpaEnergy = 0.; // ZPA Energy | |
331 | Float_t zem1Energy = 0.; // ZEM1 Energy | |
332 | Float_t zem2Energy = 0.; // ZEM2 Energy | |
333 | ||
334 | Int_t nTracks = 0; // no. tracks | |
335 | Int_t nTracklets = 0; // no. tracklets | |
336 | Int_t nClusters[6]; // no. clusters on 6 ITS layers | |
337 | Int_t nChips[2]; // no. chips on 2 SPD layers | |
338 | Float_t spdCorr =0; // corrected spd2 multiplicity | |
339 | ||
340 | Float_t multV0A = 0; // multiplicity from V0 reco side A | |
341 | Float_t multV0C = 0; // multiplicity from V0 reco side C | |
342 | Float_t multFMDA = 0; // multiplicity from FMD on detector A | |
343 | Float_t multFMDC = 0; // multiplicity from FMD on detector C | |
344 | ||
345 | Short_t v0Corr = 0; // corrected V0 multiplicity | |
346 | Short_t v0CorrResc = 0; // corrected and rescaled V0 multiplicity | |
347 | ||
348 | Float_t zvtx =0; // z-vertex SPD | |
349 | ||
350 | AliCentrality *esdCent = 0; | |
351 | ||
352 | if(fAnalysisInput.CompareTo("ESD")==0){ | |
353 | ||
354 | AliVEvent* event = InputEvent(); | |
355 | AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event); | |
356 | ||
357 | if (fRunNo<=0) { | |
358 | if (SetupRun(esd)<0) | |
359 | AliFatal("Centrality File not available for this run"); | |
360 | } | |
361 | ||
362 | esdCent = esd->GetCentrality(); | |
363 | ||
364 | // ***** V0 info | |
365 | AliESDVZERO* esdV0 = esd->GetVZEROData(); | |
366 | multV0A=esdV0->GetMTotV0A(); | |
367 | multV0C=esdV0->GetMTotV0C(); | |
368 | ||
369 | float v0CorrR; | |
370 | v0Corr = (Short_t)AliESDUtils::GetCorrV0(esd,v0CorrR); | |
371 | v0CorrResc = (Short_t)v0CorrR; | |
372 | ||
373 | // ***** Vertex Info | |
374 | const AliESDVertex* vtxESD = esd->GetPrimaryVertexSPD(); | |
375 | zvtx = vtxESD->GetZ(); | |
376 | ||
377 | // ***** CB info (tracklets, clusters, chips) | |
378 | //nTracks = event->GetNumberOfTracks(); | |
379 | nTracks = fTrackCuts ? (Short_t)fTrackCuts->GetReferenceMultiplicity(esd,kTRUE):-1; | |
380 | ||
381 | const AliMultiplicity *mult = esd->GetMultiplicity(); | |
382 | ||
383 | nTracklets = mult->GetNumberOfTracklets(); | |
384 | ||
385 | for(Int_t ilay=0; ilay<6; ilay++){ | |
386 | nClusters[ilay] = mult->GetNumberOfITSClusters(ilay); | |
387 | } | |
388 | ||
389 | for(Int_t ilay=0; ilay<2; ilay++){ | |
390 | nChips[ilay] = mult->GetNumberOfFiredChips(ilay); | |
391 | } | |
392 | ||
393 | spdCorr = AliESDUtils::GetCorrSPD2(nClusters[1],zvtx); | |
394 | ||
395 | // ***** FMD info | |
396 | AliESDFMD *fmd = esd->GetFMDData(); | |
397 | Float_t totalMultA = 0; | |
398 | Float_t totalMultC = 0; | |
399 | const Float_t fFMDLowCut = 0.4; | |
400 | ||
401 | for(UShort_t det=1;det<=3;det++) { | |
402 | Int_t nRings = (det==1 ? 1 : 2); | |
403 | for (UShort_t ir = 0; ir < nRings; ir++) { | |
404 | Char_t ring = (ir == 0 ? 'I' : 'O'); | |
405 | UShort_t nsec = (ir == 0 ? 20 : 40); | |
406 | UShort_t nstr = (ir == 0 ? 512 : 256); | |
407 | for(UShort_t sec =0; sec < nsec; sec++) { | |
408 | for(UShort_t strip = 0; strip < nstr; strip++) { | |
409 | ||
410 | Float_t FMDmult = fmd->Multiplicity(det,ring,sec,strip); | |
411 | if(FMDmult == 0 || FMDmult == AliESDFMD::kInvalidMult) continue; | |
412 | ||
413 | Float_t nParticles=0; | |
414 | ||
415 | if(FMDmult > fFMDLowCut) { | |
416 | nParticles = 1.; | |
417 | } | |
418 | ||
419 | if (det<3) totalMultA = totalMultA + nParticles; | |
420 | else totalMultC = totalMultC + nParticles; | |
421 | ||
422 | } | |
423 | } | |
424 | } | |
425 | } | |
426 | multFMDA = totalMultA; | |
427 | multFMDC = totalMultC; | |
428 | ||
429 | // ***** ZDC info | |
430 | AliESDZDC *esdZDC = esd->GetESDZDC(); | |
431 | zncEnergy = (Float_t) (esdZDC->GetZDCN1Energy())/8.; | |
432 | zpcEnergy = (Float_t) (esdZDC->GetZDCP1Energy())/8.; | |
433 | znaEnergy = (Float_t) (esdZDC->GetZDCN2Energy())/8.; | |
434 | zpaEnergy = (Float_t) (esdZDC->GetZDCP2Energy())/8.; | |
435 | zem1Energy = (Float_t) (esdZDC->GetZDCEMEnergy(0))/8.; | |
436 | zem2Energy = (Float_t) (esdZDC->GetZDCEMEnergy(1))/8.; | |
437 | ||
438 | } | |
439 | else if(fAnalysisInput.CompareTo("AOD")==0){ | |
440 | //AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent()); | |
441 | // to be implemented | |
442 | printf(" AOD analysis not yet implemented!!!\n\n"); | |
443 | return; | |
444 | } | |
445 | ||
446 | // ***** Centrality Selection | |
447 | if(fHtempV0M) fCentV0M = fHtempV0M->GetBinContent(fHtempV0M->FindBin((v0Corr))); | |
448 | /// else printf(" Centrality by V0 not available!!!\n\n"); | |
449 | if(fHtempFMD) fCentFMD = fHtempFMD->GetBinContent(fHtempFMD->FindBin((multFMDA+multFMDC))); | |
450 | // else printf(" Centrality by FMD not available!!!\n\n"); | |
451 | if(fHtempTRK) fCentTRK = fHtempTRK->GetBinContent(fHtempTRK->FindBin(nTracks)); | |
452 | // else printf(" Centrality by TRK not available!!!\n\n"); | |
453 | if(fHtempTKL) fCentTKL = fHtempTKL->GetBinContent(fHtempTKL->FindBin(nTracklets)); | |
454 | // else printf(" Centrality by TKL not available!!!\n\n"); | |
455 | if(fHtempCL0) fCentCL0 = fHtempCL0->GetBinContent(fHtempCL0->FindBin(nClusters[0])); | |
456 | // else printf(" Centrality by CL0 not available!!!\n\n"); | |
457 | if(fHtempCL1) fCentCL1 = fHtempCL1->GetBinContent(fHtempCL1->FindBin(spdCorr)); | |
458 | /// else printf(" Centrality by CL1 not available!!!\n\n"); | |
459 | ||
460 | if(fHtempV0MvsFMD) fCentV0MvsFMD = fHtempV0MvsFMD->GetBinContent(fHtempV0MvsFMD->FindBin((multV0A+multV0C))); | |
461 | // else printf(" Centrality by V0 vs FMD not available!!!\n\n"); | |
462 | if(fHtempTKLvsV0M) fCentTKLvsV0M = fHtempTKLvsV0M->GetBinContent(fHtempTKLvsV0M->FindBin(nTracklets)); | |
463 | // else printf(" Centrality by V0 vs TKL not available!!!\n\n"); | |
464 | if(fHtempZEMvsZDC) fCentZEMvsZDC = fHtempZEMvsZDC->GetBinContent(fHtempZEMvsZDC->FindBin((zem1Energy+zem2Energy)/1000.)); | |
465 | // else printf(" Centrality by ZEM vs ZDC not available!!!\n\n"); | |
466 | ||
467 | esdCent->SetCentralityV0M(fCentV0M); | |
468 | esdCent->SetCentralityFMD(fCentFMD); | |
469 | esdCent->SetCentralityTRK(fCentTRK); | |
470 | esdCent->SetCentralityTKL(fCentTKL); | |
471 | esdCent->SetCentralityCL0(fCentCL0); | |
472 | esdCent->SetCentralityCL1(fCentCL1); | |
473 | esdCent->SetCentralityV0MvsFMD(fCentV0MvsFMD); | |
474 | esdCent->SetCentralityTKLvsV0M(fCentTKLvsV0M); | |
475 | esdCent->SetCentralityZEMvsZDC(fCentZEMvsZDC); | |
476 | ||
477 | fHOutCentV0M->Fill(fCentV0M); | |
478 | fHOutCentFMD->Fill(fCentFMD); | |
479 | fHOutCentTRK->Fill(fCentTRK); | |
480 | fHOutCentTKL->Fill(fCentTKL); | |
481 | fHOutCentCL0->Fill(fCentCL0); | |
482 | fHOutCentCL1->Fill(fCentCL1); | |
483 | fHOutCentV0MvsFMD->Fill(fCentV0MvsFMD); | |
484 | fHOutCentTKLvsV0M->Fill(fCentTKLvsV0M); | |
485 | fHOutCentZEMvsZDC->Fill(fCentZEMvsZDC); | |
486 | fHOutMultV0M->Fill(v0Corr); | |
487 | fHOutMultV0R->Fill(multV0A+multV0C); | |
488 | fHOutMultFMD->Fill((multFMDA+multFMDC)); | |
489 | fHOutMultTRK->Fill(nTracks); | |
490 | fHOutMultTKL->Fill(nTracklets); | |
491 | fHOutMultCL0->Fill(nClusters[0]); | |
492 | fHOutMultCL1->Fill(spdCorr); | |
493 | fHOutMultV0MvsZDC->Fill(v0Corr,(zncEnergy+znaEnergy+zpcEnergy+zpaEnergy)); | |
494 | fHOutMultZEMvsZDC->Fill((zem1Energy+zem2Energy),(zncEnergy+znaEnergy+zpcEnergy+zpaEnergy)); | |
495 | fHOutMultV0MvsCL1->Fill(v0Corr,spdCorr); | |
496 | fHOutMultV0MvsTRK->Fill(v0Corr,nTracks); | |
497 | fHOutMultTRKvsCL1->Fill(nTracks,spdCorr); | |
498 | ||
499 | PostData(1, fOutputList); | |
500 | } | |
501 | ||
502 | //________________________________________________________________________ | |
503 | void AliCentralitySelectionTask::ReadCentralityHistos(TString fCentfilename) | |
504 | { | |
505 | // Read centrality histograms | |
506 | TDirectory *owd = gDirectory; | |
507 | // Check if the file is present | |
508 | TString path = gSystem->ExpandPathName(fCentfilename.Data()); | |
509 | if (gSystem->AccessPathName(path)) { | |
510 | AliError(Form("File %s does not exist", path.Data())); | |
511 | return; | |
512 | } | |
513 | fFile = TFile::Open(fCentfilename); | |
514 | owd->cd(); | |
515 | fHtempV0M = (TH1F*) (fFile->Get("hmultV0_percentile")); | |
516 | fHtempFMD = (TH1F*) (fFile->Get("hmultFMD_percentile")); | |
517 | fHtempTRK = (TH1F*) (fFile->Get("hNtracks_percentile")); | |
518 | fHtempTKL = (TH1F*) (fFile->Get("hNtracklets_percentile")); | |
519 | fHtempCL0 = (TH1F*) (fFile->Get("hNclusters0_percentile")); | |
520 | fHtempCL1 = (TH1F*) (fFile->Get("hNclusters1_percentile")); | |
521 | owd->cd(); | |
522 | } | |
523 | ||
524 | //________________________________________________________________________ | |
525 | void AliCentralitySelectionTask::ReadCentralityHistos2(TString fCentfilename2) | |
526 | { | |
527 | // Read centrality histograms | |
528 | TDirectory *owd = gDirectory; | |
529 | TString path = gSystem->ExpandPathName(fCentfilename2.Data()); | |
530 | if (gSystem->AccessPathName(path)) { | |
531 | AliError(Form("File %s does not exist", path.Data())); | |
532 | return; | |
533 | } | |
534 | fFile2 = TFile::Open(fCentfilename2); | |
535 | owd->cd(); | |
536 | fHtempV0MvsFMD = (TH1F*) (fFile2->Get("hmultV0vsmultFMD_all_percentile")); | |
537 | fHtempTKLvsV0M = (TH1F*) (fFile2->Get("hNtrackletsvsmultV0_all_percentile")); | |
538 | fHtempZEMvsZDC = (TH1F*) (fFile2->Get("hEzemvsEzdc_all_percentile")); | |
539 | owd->cd(); | |
540 | } | |
541 | ||
542 | //________________________________________________________________________ | |
543 | void AliCentralitySelectionTask::Terminate(Option_t */*option*/) | |
544 | { | |
545 | // Terminate analysis | |
546 | if (fFile && fFile->IsOpen()) | |
547 | fFile->Close(); | |
548 | if (fFile2 && fFile2->IsOpen()) | |
549 | fFile2->Close(); | |
550 | } | |
551 | //________________________________________________________________________ | |
552 | Int_t AliCentralitySelectionTask::SetupRun(AliESDEvent* esd) | |
553 | { | |
554 | // Setup files for run | |
555 | ||
556 | if (!esd) | |
557 | return -1; | |
558 | ||
559 | // check if something to be done | |
560 | if (fCurrentRun == esd->GetRunNumber()) | |
561 | return 0; | |
562 | else | |
563 | fCurrentRun = esd->GetRunNumber(); | |
564 | ||
565 | AliInfo(Form("Setup Centrality Selection for run %d\n",fCurrentRun)); | |
566 | ||
567 | fRunNo = fCurrentRun; | |
568 | ||
569 | // CHANGE HERE FOR RUN RANGES | |
570 | if ( fRunNo <= 137162 ) fRunNo = 137161; | |
571 | else if ( fRunNo == 137365 ) fRunNo = 137366; | |
572 | else if ( fRunNo >= 137366 ) fRunNo = 137366; | |
573 | // CHANGE HERE FOR RUN RANGES | |
574 | ||
575 | TString fileName(Form("%s/AliCentralityBy1D_%d.root", fDirName.Data(), fRunNo)); | |
576 | TString fileName2(Form("%s/AliCentralityByFunction_%d.root", fDirName.Data(), fRunNo)); | |
577 | ||
578 | AliInfo(Form("Centrality Selection for run %d is initialized with %s", fCurrentRun, fileName.Data())); | |
579 | ReadCentralityHistos(fileName.Data()); | |
580 | ReadCentralityHistos2(fileName2.Data()); | |
581 | if (!fFile && !fFile2) { | |
582 | AliFatal(Form("Run %d not known to centrality selection!", fCurrentRun)); | |
583 | return -1; | |
584 | } | |
585 | return 0; | |
586 | } |