]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG1/global/AliAnalysisTaskVertexESD.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
macro to fetch the AliITSRecoPAram object from the OCDB
[u/mrichter/AliRoot.git] / PWG1 / global / AliAnalysisTaskVertexESD.cxx
CommitLineData
388ca814 1/**************************************************************************
2 * Copyright(c) 1998-2009, 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 AliAnalysisTaskVertexESD
18// AliAnalysisTask to extract from ESD the information for the analysis
19// of the primary vertex reconstruction efficiency and resolution
20// (for MC events) and distributions (for real data). Three vertices:
21// - SPD tracklets
22// - ITS+TPC tracks
23// - TPC-only tracks
24//
25// Author: A.Dainese, andrea.dainese@pd.infn.it
26//*************************************************************************
27
28#include <TChain.h>
29#include <TTree.h>
30#include <TNtuple.h>
31#include <TBranch.h>
32#include <TClonesArray.h>
33#include <TObjArray.h>
34#include <TH1F.h>
35#include <TH2F.h>
36#include <TCanvas.h>
a874bb01 37#include <TGraphAsymmErrors.h>
38#include <TFile.h>
388ca814 39
40#include "AliAnalysisTask.h"
41#include "AliAnalysisManager.h"
42
43#include "AliMultiplicity.h"
44#include "AliVertexerTracks.h"
45#include "AliESDtrack.h"
46#include "AliExternalTrackParam.h"
47#include "AliESDVertex.h"
65602ad2 48#include "AliVEvent.h"
388ca814 49#include "AliESDInputHandler.h"
388ca814 50#include "AliTrackReference.h"
38d12819 51//#include "AliTriggerAnalysis.h"
388ca814 52
53#include "AliMCEventHandler.h"
54#include "AliMCEvent.h"
55#include "AliStack.h"
56#include "AliLog.h"
57
58#include "AliGenEventHeader.h"
59#include "AliAnalysisTaskVertexESD.h"
60
61
62ClassImp(AliAnalysisTaskVertexESD)
63
64//________________________________________________________________________
65AliAnalysisTaskVertexESD::AliAnalysisTaskVertexESD(const char *name) :
74917c1f 66AliAnalysisTaskSE(name),
a874bb01 67 fCheckEventType(kTRUE),
68 fReadMC(kFALSE),
d0bbaf02 69 fRecoVtxTPC(kTRUE),
a874bb01 70 fRecoVtxITSTPC(kTRUE),
71 fRecoVtxITSTPCHalfEvent(kFALSE),
72 fOnlyITSTPCTracks(kFALSE),
73 fOnlyITSSATracks(kFALSE),
74 fFillNtuple(kFALSE),
75 fFillTreeBeamSpot(kFALSE),
76 fESD(0),
77 fOutput(0),
78 fNtupleVertexESD(0),
79 fhSPDVertexX(0),
80 fhSPDVertexY(0),
81 fhSPDVertexZ(0),
9f076c54 82 fhSPDVertexZonly(0),
a874bb01 83 fhTRKVertexX(0),
84 fhTRKVertexY(0),
85 fhTRKVertexZ(0),
86 fhTPCVertexX(0),
87 fhTPCVertexY(0),
88 fhTPCVertexZ(0),
89 fhTrackRefs(0),
90 fTreeBeamSpot(0),
91 fhTriggeredTrklets(0),
92 fhSPD3DTrklets(0),
93 fhSPDZTrklets(0),
94 fhTRKTrklets(0),
95 fhTRKcTrklets(0),
96 fhTRKncTrklets(0),
d0bbaf02 97 fhTPCTrklets(0),
98 fhTPCcTrklets(0),
99 fhTPCncTrklets(0),
a874bb01 100 fhSPD3DZreco(0),
101 fhSPDZZreco(0),
102 fhSPDVertexXPile(0),
103 fhSPDVertexYPile(0),
104 fhSPDVertexZPile(0),
8d3b93cb 105 fhSPDVertexDiffZPileContr2(0),
106 fhSPDVertexDiffZPileContr3(0),
107 fhSPDVertexDiffZPileContr4(0),
108 fhSPDVertexDiffZPileContr5(0),
68d70d53 109 fhSPDVertexDiffZPileDefault(0),
a874bb01 110 fhSPDContributorsPile(0),
65602ad2 111 fhSPDDispContributors(0),
9f076c54 112 fTriggerType(AliVEvent::kMB),
113 fhntrksSPDvsSPDcls(0),
114 fhntrksZvsSPDcls(0)
388ca814 115{
116 // Constructor
117
118 // Define input and output slots here
388ca814 119 // Output slot #0 writes into a TList container
41deb8e3 120 DefineOutput(1, TList::Class()); //My private output
388ca814 121}
122//________________________________________________________________________
123AliAnalysisTaskVertexESD::~AliAnalysisTaskVertexESD()
124{
125 // Destructor
126
127 // histograms are in the output list and deleted when the output
128 // list is deleted by the TSelector dtor
129
9c12af5f 130 if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
388ca814 131 delete fOutput;
132 fOutput = 0;
133 }
134}
135
388ca814 136
137//________________________________________________________________________
74917c1f 138void AliAnalysisTaskVertexESD::UserCreateOutputObjects()
388ca814 139{
140 // Create histograms
141 // Called once
142
143 // Several histograms are more conveniently managed in a TList
144 fOutput = new TList;
145 fOutput->SetOwner();
146
68d70d53 147 fNtupleVertexESD = new TNtuple("fNtupleVertexESD","vertices","run:tstamp:bunchcross:triggered:dndygen:xdiam:ydiam:zdiam:xerrdiam:yerrdiam:zerrdiam:xtrue:ytrue:ztrue:xSPD:xerrSPD:ySPD:yerrSPD:zSPD:zerrSPD:ntrksSPD:SPD3D:dphiSPD:xTPC:xerrTPC:yTPC:yerrTPC:zTPC:zerrTPC:ntrksTPC:constrTPC:xTRK:xerrTRK:yTRK:yerrTRK:zTRK:zerrTRK:ntrksTRK:constrTRK:ntrklets:nESDtracks:nITSrefit5or6:nTPCin:nTPCinEta09:SPD0cls:ispileupfromSPDdefault:xSPDp:xerrSPDp:ySPDp:yerrSPDp:zSPDp:zerrSPDp:ntrksSPDp:xTPCnc:xerrTPCnc:yTPCnc:yerrTPCnc:zTPCnc:zerrTPCnc:ntrksTPCnc:xTPCc:xerrTPCc:yTPCc:yerrTPCc:zTPCc:zerrTPCc:ntrksTPCc:xTRKnc:xerrTRKnc:yTRKnc:yerrTRKnc:zTRKnc:zerrTRKnc:ntrksTRKnc:xTRKc:xerrTRKc:yTRKc:yerrTRKc:zTRKc:zerrTRKc:ntrksTRKc:deltaxTRKnc:deltayTRKnc:deltazTRKnc:deltaxerrTRKnc:deltayerrTRKnc:deltazerrTRKnc:ntrksEvenTRKnc:ntrksOddTRKnc");
388ca814 148
149 fOutput->Add(fNtupleVertexESD);
150
b588553c 151 fhSPDVertexX = new TH1F("fhSPDVertexX","SPDVertex x; x vertex [cm]; events",200,-1,1);
152 fOutput->Add(fhSPDVertexX);
153 fhSPDVertexY = new TH1F("fhSPDVertexY","SPDVertex y; y vertex [cm]; events",200,-1,1);
154 fOutput->Add(fhSPDVertexY);
155 fhSPDVertexZ = new TH1F("fhSPDVertexZ","SPDVertex z; z vertex [cm]; events",200,-20,20);
156 fOutput->Add(fhSPDVertexZ);
9f076c54 157
158 fhSPDVertexZonly = new TH1F("fhSPDVertexZonly","SPDVertexer z; z vertex [cm]; events",200,-20,20);
159 fOutput->Add(fhSPDVertexZonly);
160
b588553c 161 fhTRKVertexX = new TH1F("fhTRKVertexX","TRKVertex x; x vertex [cm]; events",200,-1,1);
162 fOutput->Add(fhTRKVertexX);
163 fhTRKVertexY = new TH1F("fhTRKVertexY","TRKVertex y; y vertex [cm]; events",200,-1,1);
164 fOutput->Add(fhTRKVertexY);
165 fhTRKVertexZ = new TH1F("fhTRKVertexZ","TRKVertex z; z vertex [cm]; events",200,-20,20);
166 fOutput->Add(fhTRKVertexZ);
167 fhTPCVertexX = new TH1F("fhTPCVertexX","TPCVertex x; x vertex [cm]; events",200,-3,3);
168 fOutput->Add(fhTPCVertexX);
169 fhTPCVertexY = new TH1F("fhTPCVertexY","TPCVertex y; y vertex [cm]; events",200,-3,3);
170 fOutput->Add(fhTPCVertexY);
171 fhTPCVertexZ = new TH1F("fhTPCVertexZ","TPCVertex z; z vertex [cm]; events",200,-20,20);
172 fOutput->Add(fhTPCVertexZ);
a874bb01 173
174
175 fhSPDVertexXPile = new TH1F("fhSPDVertexXPile","SPDVertexPile x; x vertex [cm]; events",200,-20,20);
176 fOutput->Add(fhSPDVertexXPile);
177 fhSPDVertexYPile = new TH1F("fhSPDVertexYPile","SPDVertexPile y; y vertex [cm]; events",200,-20,20);
178 fOutput->Add(fhSPDVertexYPile);
179 fhSPDVertexZPile = new TH1F("fhSPDVertexZPile","SPDVertexPile z; z vertex [cm]; events",200,-40,40);
180 fOutput->Add(fhSPDVertexZPile);
8d3b93cb 181
68d70d53 182 fhSPDVertexDiffZPileContr2 = new TH1F("fhSPDVertexDiffZPileContr2","SPDVertexDiff z; zmain - zpile [cm]; events",2000,-100,100);
8d3b93cb 183 fOutput->Add(fhSPDVertexDiffZPileContr2);
68d70d53 184 fhSPDVertexDiffZPileContr3 = new TH1F("fhSPDVertexDiffZPileContr3","SPDVertexDiff z; zmain - zpile [cm]; events",2000,-100,100);
8d3b93cb 185 fOutput->Add(fhSPDVertexDiffZPileContr3);
68d70d53 186 fhSPDVertexDiffZPileContr4 = new TH1F("fhSPDVertexDiffZPileContr4","SPDVertexDiff z; zmain - zpile [cm]; events",2000,-100,100);
8d3b93cb 187 fOutput->Add(fhSPDVertexDiffZPileContr4);
68d70d53 188 fhSPDVertexDiffZPileContr5 = new TH1F("fhSPDVertexDiffZPileContr5","SPDVertexDiff z; zmain - zpile [cm]; events",2000,-100,100);
8d3b93cb 189 fOutput->Add(fhSPDVertexDiffZPileContr5);
68d70d53 190 fhSPDVertexDiffZPileDefault = new TH1F("fhSPDVertexDiffZPileDefault","SPDVertexDiff z; zmain - zpile [cm]; events",2000,-100,100);
191 fOutput->Add(fhSPDVertexDiffZPileDefault);
b588553c 192
388ca814 193 fhTrackRefs = new TH2F("fhTrackRefs","Track references; x; y",1000,-4,4,1000,-4,4);
194 fOutput->Add(fhTrackRefs);
195
4f0574ad 196 fTreeBeamSpot = new TTree("fTreeBeamSpot", "BeamSpotTree");
197 UShort_t triggered, ntrkletsS, ntrksTRKnc;
198 UInt_t run, bx;
199 Float_t cetTimeLHC,xTRKnc, yTRKnc, zTRKnc;
200 fTreeBeamSpot->Branch("run", &run, "run/i");
201 fTreeBeamSpot->Branch("cetTimeLHC", &cetTimeLHC, "cetTimeLHC/F");
202 fTreeBeamSpot->Branch("bx", &bx, "bx/i");
203 fTreeBeamSpot->Branch("triggered", &triggered, "triggered/s");
204 fTreeBeamSpot->Branch("ntrkletsS", &ntrkletsS, "ntrkletsS/s");
205 fTreeBeamSpot->Branch("xTRKnc", &xTRKnc, "xTRKnc/F");
206 fTreeBeamSpot->Branch("yTRKnc", &yTRKnc, "yTRKnc/F");
207 fTreeBeamSpot->Branch("zTRKnc", &zTRKnc, "zTRKnc/F");
208 fTreeBeamSpot->Branch("ntrksTRKnc", &ntrksTRKnc, "ntrksTRKnc/s");
209 fOutput->Add(fTreeBeamSpot);
aea5af08 210
d0bbaf02 211 Int_t nbinTrklets=29;
212 Float_t lowTrklets[30]={-0.5,0.5,1.5,2.5,3.5,4.5,5.5,7.5,10.5,25.5,50.5,75.5,100.5,150.5,200.5,300.5,400.5,500.5,600.5,800.5,1000.5,1500.5,2000.5,2500.5,3000.5,4000.5,5000.5,6000.5,8000.5,10000.5};
a874bb01 213 fhTriggeredTrklets = new TH1F("fhTriggeredTrklets","trklets dist for triggered ev.; ntrklets; entries",nbinTrklets,lowTrklets);
214 fOutput->Add(fhTriggeredTrklets);
215 fhSPD3DTrklets = new TH1F("fhSPD3DTrklets","trklets dist for SPD3D ev.; ntrklets; entries",nbinTrklets,lowTrklets);
216 fOutput->Add(fhSPD3DTrklets);
217 fhSPDZTrklets = new TH1F("fhSPDZTrklets","trklets dist for SPDZ ev.; ntrklets; entries",nbinTrklets,lowTrklets);
218 fOutput->Add(fhSPDZTrklets);
219 fhTRKTrklets = new TH1F("fhTRKTrklets","trklets dist for TRK ev.; ntrklets; entries",nbinTrklets,lowTrklets);
220 fOutput->Add(fhTRKTrklets);
221 fhTRKcTrklets = new TH1F("fhTRKcTrklets","trklets dist for TRKc ev.; ntrklets; entries",nbinTrklets,lowTrklets);
222 fOutput->Add(fhTRKcTrklets);
223 fhTRKncTrklets = new TH1F("fhTRKncTrklets","trklets dist for TRKnc ev.; ntrklets; entries",nbinTrklets,lowTrklets);
224 fOutput->Add(fhTRKncTrklets);
d0bbaf02 225 fhTPCTrklets = new TH1F("fhTPCTrklets","trklets dist for TPC ev.; ntrklets; entries",nbinTrklets,lowTrklets);
226 fOutput->Add(fhTPCTrklets);
227 fhTPCcTrklets = new TH1F("fhTPCcTrklets","trklets dist for TPCc ev.; ntrklets; entries",nbinTrklets,lowTrklets);
228 fOutput->Add(fhTPCcTrklets);
229 fhTPCncTrklets = new TH1F("fhTPCncTrklets","trklets dist for TPCnc ev.; ntrklets; entries",nbinTrklets,lowTrklets);
230 fOutput->Add(fhTPCncTrklets);
a874bb01 231
232 Int_t nbinZreco = 16;
233 Double_t lowZreco[17]={-15.0,-10.0,-7.0,-5,-4,-3,-2,-1,0,1,2,3,4,5,7,10,15};
234 fhSPD3DZreco = new TH1F("fhSPD3DZreco","Zreco dist for SPD3D ev.; Zreco [cm]; entries",nbinZreco,lowZreco);
235 fOutput->Add(fhSPD3DZreco);
236 fhSPDZZreco = new TH1F("fhSPDZZreco","Zreco dist for SPDZ ev.; Zreco [cm]; entries",nbinZreco,lowZreco);
237 fOutput->Add(fhSPDZZreco);
238
239 fhSPDContributorsPile = new TH1F("fhSPDContributorsPile","ncontributors pile up vertex; ncontributors; entries",200,-0.5,199.5);
240 fOutput->Add(fhSPDContributorsPile);
241
242 fhSPDDispContributors = new TH2F("fhSPDDispContributors","ncontributors main-pile; ncontributors main; ncontributors pile",200,-0.5,199.5,200,-0.5,199.5);
243 fOutput->Add(fhSPDDispContributors);
244
9f076c54 245 fhntrksSPDvsSPDcls = new TH2F("fhntrksSPDvsSPDcls", "ncontributors SPD3D vs number of cluster SPD; nContributors 3D; nCluster SPD1",300,0.,3000.,400,0.,8000.);
246 fOutput->Add(fhntrksSPDvsSPDcls);
247
248 fhntrksZvsSPDcls = new TH2F("fhntrksZvsSPDcls", "ncontributors SPDZ vs number of cluster SPD; nContributors Z; nCluster SPD1",300,0.,3000.,400,0.,8000.);
249 fOutput->Add(fhntrksZvsSPDcls);
250
997f86cb 251 PostData(1, fOutput);
30b05a14 252
f6232e6e 253 return;
388ca814 254}
255
256//________________________________________________________________________
74917c1f 257void AliAnalysisTaskVertexESD::UserExec(Option_t *)
388ca814 258{
259 // Main loop
260 // Called for each event
261
74917c1f 262 if (!InputEvent()) {
388ca814 263 Printf("ERROR: fESD not available");
264 return;
265 }
74917c1f 266 AliESDEvent* esdE = (AliESDEvent*) InputEvent();
267
129c7f70 268 // Select PHYSICS events (type=7, for data) and MC events (type=0)
269 // fCheckEventType is kFALSE if fReadMC is kTRUE, hence check is skipped
270 if(fCheckEventType) {
271 if(esdE->GetEventType()!=7 && esdE->GetEventType()!=0) return;
272 }
38d12819 273
274
388ca814 275 TArrayF mcVertex(3);
276 mcVertex[0]=9999.; mcVertex[1]=9999.; mcVertex[2]=9999.;
277 Float_t dNchdy=-999.;
388ca814 278 // *********** MC info ***************
279 if (fReadMC) {
280 AliMCEventHandler* eventHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
281 if (!eventHandler) {
282 Printf("ERROR: Could not retrieve MC event handler");
283 return;
284 }
285
286 AliMCEvent* mcEvent = eventHandler->MCEvent();
287 if (!mcEvent) {
288 Printf("ERROR: Could not retrieve MC event");
289 return;
290 }
291
292 AliStack* stack = mcEvent->Stack();
293 if (!stack) {
294 AliDebug(AliLog::kError, "Stack not available");
295 return;
296 }
297
298 AliHeader* header = mcEvent->Header();
299 if (!header) {
300 AliDebug(AliLog::kError, "Header not available");
301 return;
302 }
303 AliGenEventHeader* genHeader = header->GenEventHeader();
304 genHeader->PrimaryVertex(mcVertex);
305
306 Int_t ngenpart = (Int_t)stack->GetNtrack();
307 //printf("# generated particles = %d\n",ngenpart);
308 dNchdy=0;
309 for(Int_t ip=0; ip<ngenpart; ip++) {
310 TParticle* part = (TParticle*)stack->Particle(ip);
311 // keep only electorns, muons, pions, kaons and protons
312 Int_t apdg = TMath::Abs(part->GetPdgCode());
313 if(apdg!=11 && apdg!=13 && apdg!=211 && apdg!=321 && apdg!=2212) continue;
314 // reject secondaries
315 if(TMath::Sqrt((part->Vx()-mcVertex[0])*(part->Vx()-mcVertex[0])+(part->Vy()-mcVertex[1])*(part->Vy()-mcVertex[1]))>0.0010) continue;
316 // reject incoming protons
317 Double_t energy = part->Energy();
318 if(energy>900.) continue;
319 Double_t pz = part->Pz();
320 Double_t y = 0.5*TMath::Log((energy+pz+1.e-13)/(energy-pz+1.e-13));
321 if(TMath::Abs(y)<1.0) dNchdy += 0.5; // count 1/2 of particles in |y|<1
322 // tracks refs
323 TClonesArray *trefs=0;
324 Int_t ntrefs = mcEvent->GetParticleAndTR(ip,part,trefs);
325 if(ntrefs<0) continue;
326 for(Int_t iref=0; iref<ntrefs; iref++) {
327 AliTrackReference *tref = (AliTrackReference*)trefs->At(iref);
328 if(tref->R()>10.) continue;
329 fhTrackRefs->Fill(tref->X(),tref->Y());
330 }
331 }
332 //printf("# primary particles = %7.1f\n",dNchdy);
333 }
334 // *********** MC info ***************
335
388ca814 336
337 // Trigger
38d12819 338 //ULong64_t triggerMask;
339 //ULong64_t spdFO = (1 << 14);
340 //ULong64_t v0left = (1 << 10);
341 //ULong64_t v0right = (1 << 11);
388ca814 342
74917c1f 343 //triggerMask=esdE->GetTriggerMask();
388ca814 344 // MB1: SPDFO || V0L || V0R
38d12819 345 //Bool_t eventTriggered = (triggerMask & spdFO || ((triggerMask & v0left) || (triggerMask & v0right)));
388ca814 346 //MB2: GFO && V0R
347 //triggerMask & spdFO && ((triggerMask&v0left) || (triggerMask&v0right))
65602ad2 348 //Bool_t eventTriggered = (triggerMask & spdFO);
388ca814 349
38d12819 350 //static AliTriggerAnalysis* triggerAnalysis = new AliTriggerAnalysis();
74917c1f 351 Bool_t eventTriggered = 0;//triggerAnalysis->IsTriggerFired(esdE, AliTriggerAnalysis::kSPDGFO /*| AliTriggerAnalysis::kOfflineFlag*/);
388ca814 352
8c7764e0 353 // use response of AliPhysicsSelection
65602ad2 354 eventTriggered = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & fTriggerType);
8c7764e0 355
4f0574ad 356
357 Int_t nInFile = esdE->GetEventNumberInFile();
358
30b05a14 359 const AliMultiplicity *alimult = esdE->GetMultiplicity();
9f076c54 360 Int_t ntrklets=0,spd0cls=0, spd1cls=0;
30b05a14 361 if(alimult) {
362 ntrklets = alimult->GetNumberOfTracklets();
363
30b05a14 364 for(Int_t l=0;l<alimult->GetNumberOfTracklets();l++){
365 if(alimult->GetDeltaPhi(l)<-9998.) ntrklets--;
366 }
367 spd0cls = alimult->GetNumberOfSingleClusters()+ntrklets;
9f076c54 368 spd1cls = alimult->GetNumberOfITSClusters(1);
30b05a14 369 }
370
371
4f0574ad 372 UShort_t triggered, ntrkletsS, ntrksTRKnc;
373 UInt_t run, bx;
374 Float_t cetTimeLHC,xTRKnc, yTRKnc, zTRKnc;
375 fTreeBeamSpot->SetBranchAddress("run", &run);
376 fTreeBeamSpot->SetBranchAddress("cetTimeLHC", &cetTimeLHC);
377 fTreeBeamSpot->SetBranchAddress("bx", &bx);
378 fTreeBeamSpot->SetBranchAddress("triggered", &triggered);
379 fTreeBeamSpot->SetBranchAddress("ntrkletsS", &ntrkletsS);
380 fTreeBeamSpot->SetBranchAddress("xTRKnc", &xTRKnc);
381 fTreeBeamSpot->SetBranchAddress("yTRKnc", &yTRKnc);
382 fTreeBeamSpot->SetBranchAddress("zTRKnc", &zTRKnc);
383 fTreeBeamSpot->SetBranchAddress("ntrksTRKnc", &ntrksTRKnc);
384
385
aea5af08 386 Double_t tstamp = esdE->GetTimeStamp();
387 Float_t cetTime =(tstamp-1262304000.)+7200.;
388
389 Float_t cetTime1h =(tstamp-1262304000.)+3600.;
30b05a14 390
4f0574ad 391 cetTimeLHC = (Float_t)cetTime1h;
392
74917c1f 393 Int_t ntracks = esdE->GetNumberOfTracks();
388ca814 394 Int_t nITS5or6=0,nTPCin=0,nTPCinEta09=0;
74917c1f 395 //printf("Tracks # = %d\n",esdE->GetNumberOfTracks());
388ca814 396 for(Int_t itr=0; itr<ntracks; itr++) {
74917c1f 397 AliESDtrack *t = esdE->GetTrack(itr);
388ca814 398 if(t->GetNcls(0)>=5) nITS5or6++;
74917c1f 399 Double_t z0; t->GetZAt(0,esdE->GetMagneticField(),z0);
400 if(t->GetNcls(1)>0 && TMath::Abs(t->GetD(0,0,esdE->GetMagneticField()))<2.8 && TMath::Abs(z0)<20) {
388ca814 401 nTPCin++;
402 if(TMath::Abs(t->GetTgl())<1.5) nTPCinEta09++;
403 }
388ca814 404 }
405
4f0574ad 406
74917c1f 407 const AliESDVertex *spdv=esdE->GetPrimaryVertexSPD();
39258194 408 const AliESDVertex *spdvp=esdE->GetPileupVertexSPD(0);
74917c1f 409 const AliESDVertex *tpcv=esdE->GetPrimaryVertexTPC();
410 const AliESDVertex *trkv=esdE->GetPrimaryVertexTracks();
b588553c 411
412 // fill histos
413
414 if(spdv) {
415 if(spdv->GetNContributors()>0) {
416 TString title=spdv->GetTitle();
417 if(title.Contains("3D")) {
9f076c54 418 fhSPDVertexX->Fill(spdv->GetXv());
419 fhSPDVertexY->Fill(spdv->GetYv());
420 fhSPDVertexZ->Fill(spdv->GetZv());
421
422 fhntrksSPDvsSPDcls->Fill(spdv->GetNContributors(), spd0cls);
b588553c 423 }
9f076c54 424 if(title.Contains("Z")){
425 fhSPDVertexZonly->Fill(spdv->GetZv());
426 fhntrksZvsSPDcls->Fill(spdv->GetNContributors(), spd1cls);
427 }
428 }
b588553c 429 }
9f076c54 430
b588553c 431 if(trkv) {
432 if(trkv->GetNContributors()>0) {
433 fhTRKVertexX->Fill(trkv->GetXv());
434 fhTRKVertexY->Fill(trkv->GetYv());
435 fhTRKVertexZ->Fill(trkv->GetZv());
436 }
437 }
438
439 if(tpcv) {
440 if(tpcv->GetNContributors()>0) {
441 fhTPCVertexX->Fill(tpcv->GetXv());
442 fhTPCVertexY->Fill(tpcv->GetYv());
443 fhTPCVertexZ->Fill(tpcv->GetZv());
444 }
445 }
39258194 446
a874bb01 447
448
449 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
a874bb01 450 // filling Vertex reco efficiency plots
d0bbaf02 451
a874bb01 452 if(eventTriggered ? 1. : 0.){
453 fhTriggeredTrklets->Fill(ntrklets);
d0bbaf02 454
455 if(spdv){
456 if(spdv->GetNContributors()>0.5){
457 TString spdtitle = spdv->GetTitle();
458 if(spdtitle.Contains("vertexer: 3D") ? 1. : 0.){
459 fhSPD3DTrklets->Fill(ntrklets);
460 fhSPD3DZreco->Fill(spdv->GetZv());
461 }
462 else{
463 fhSPDZTrklets->Fill(ntrklets);
464 fhSPDZZreco->Fill(spdv->GetZv());
465 }
a874bb01 466 }
467 }
d0bbaf02 468
469 if(trkv){
470 if(trkv->GetNContributors()>0.5)fhTRKTrklets->Fill(ntrklets);
471 }
a874bb01 472 if(fRecoVtxITSTPC) {
473 AliESDVertex *trkvc = ReconstructPrimaryVertexITSTPC(kTRUE);
474 if(trkvc->GetNContributors()>0.5)fhTRKcTrklets->Fill(ntrklets);
475 delete trkvc; trkvc=0;
476 AliESDVertex *trkvnc = ReconstructPrimaryVertexITSTPC(kFALSE);
477 if(trkvnc->GetNContributors()>0.5)fhTRKncTrklets->Fill(ntrklets);
478 delete trkvnc; trkvnc=0;
d0bbaf02 479 }
480
481 if(tpcv){
482 if(tpcv->GetNContributors()>0.5)fhTPCTrklets->Fill(ntrklets);
483 }
484 if(fRecoVtxTPC) {
485 AliESDVertex *tpcvc = ReconstructPrimaryVertexTPC(kTRUE);
486 if(tpcvc->GetNContributors()>0.5)fhTPCcTrklets->Fill(ntrklets);
487 delete tpcvc; tpcvc=0;
488 AliESDVertex *tpcvnc = ReconstructPrimaryVertexTPC(kFALSE);
489 if(tpcvnc->GetNContributors()>0.5)fhTPCncTrklets->Fill(ntrklets);
490 delete tpcvnc; tpcvnc=0;
491 }
a874bb01 492 }
493 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
494
39258194 495 Float_t xpile=-999.;
496 Float_t ypile=-999.;
497 Float_t zpile=-999.;
498 Float_t expile=-999.;
499 Float_t eypile=-999.;
500 Float_t ezpile=-999.;
501 Int_t ntrkspile=-1;
68d70d53 502 Bool_t isPileUpfromSPD=esdE->IsPileupFromSPD();
39258194 503
b6292968 504 if(esdE->GetNumberOfPileupVerticesSPD()>0 && spdvp && spdv){
a874bb01 505
68d70d53 506 if(spdvp->GetNContributors()>=2) {
507
508 xpile=spdvp->GetXv();
509 expile=spdvp->GetXRes();
510 ypile=spdvp->GetYv();
511 eypile=spdvp->GetYRes();
512 zpile=spdvp->GetZv();
513 ezpile=spdvp->GetZRes();
514 ntrkspile=spdvp->GetNContributors();
515
516 if (esdE->IsPileupFromSPD(2,0.,3.,2.,5.)){
517
518 fhSPDVertexDiffZPileContr2->Fill(spdv->GetZv()-spdvp->GetZv());
519 if(spdvp->GetNContributors()>=3) {fhSPDVertexDiffZPileContr3->Fill(spdv->GetZv()-spdvp->GetZv());}
520 if(spdvp->GetNContributors()>=4) {fhSPDVertexDiffZPileContr4->Fill(spdv->GetZv()-spdvp->GetZv());}
521 if(spdvp->GetNContributors()>=5) {fhSPDVertexDiffZPileContr5->Fill(spdv->GetZv()-spdvp->GetZv());}
522
523 }//end IsPileUpFromSPD
8d3b93cb 524
68d70d53 525 if (isPileUpfromSPD){
526
527 fhSPDVertexXPile->Fill(spdvp->GetXv());
528 fhSPDVertexYPile->Fill(spdvp->GetYv());
529 fhSPDVertexZPile->Fill(spdvp->GetZv());
530 fhSPDContributorsPile->Fill(spdvp->GetNContributors());
531 fhSPDDispContributors->Fill(spdv->GetNContributors(),spdvp->GetNContributors());
532 fhSPDVertexDiffZPileDefault->Fill(spdv->GetZv()-spdvp->GetZv());
a874bb01 533
68d70d53 534 }
535 }
39258194 536 }
68d70d53 537
b588553c 538 // fill ntuple
68d70d53 539 Int_t isize=89;
540 Float_t xnt[89]; for(Int_t iii=0;iii<isize;iii++) xnt[iii]=0.;
30b05a14 541
aea5af08 542 Int_t isizeSecNt=9;
543 Float_t secnt[9]; for(Int_t iii=0;iii<isizeSecNt;iii++) secnt[iii]=0.;
30b05a14 544
97805f7d 545 Int_t index=0;
30b05a14 546 Int_t indexSecNt=0;
97805f7d 547
74917c1f 548 xnt[index++]=(Float_t)esdE->GetRunNumber();
30b05a14 549 secnt[indexSecNt++]=(Float_t)esdE->GetRunNumber();
4f0574ad 550 run = (Int_t)esdE->GetRunNumber();
8c7764e0 551
30b05a14 552 xnt[index++]=cetTime; //(Float_t)esdE->GetTimeStamp();
aea5af08 553 //secnt[indexSecNt++]=cetTime;
554 secnt[indexSecNt++]=cetTime1h;
8c7764e0 555
30b05a14 556 xnt[index++]=(Float_t)esdE->GetBunchCrossNumber();
4f0574ad 557 secnt[indexSecNt++]=(Float_t)esdE->GetBunchCrossNumber();
558 bx = (Int_t)esdE->GetBunchCrossNumber();
97805f7d 559
30b05a14 560 xnt[index++]=(eventTriggered ? 1. : 0.);
561 secnt[indexSecNt++]=(eventTriggered ? 1. : 0.);
4f0574ad 562 triggered = (UShort_t)(eventTriggered ? 1 : 0);
563
30b05a14 564 xnt[index++]=(Float_t)dNchdy;
565
68d70d53 566 xnt[index++]=(Float_t)esdE->GetDiamondX();
567 xnt[index++]=(Float_t)esdE->GetDiamondY();
568 xnt[index++]=(Float_t)esdE->GetDiamondZ();
569
570 xnt[index++]=(Float_t)(TMath::Sqrt(esdE->GetSigma2DiamondX()));
571 xnt[index++]=(Float_t)(TMath::Sqrt(esdE->GetSigma2DiamondY()));
572 xnt[index++]=(Float_t)(TMath::Sqrt(esdE->GetSigma2DiamondZ()));
573
574
97805f7d 575 xnt[index++]=mcVertex[0];
576 xnt[index++]=mcVertex[1];
577 xnt[index++]=mcVertex[2];
388ca814 578
97805f7d 579 xnt[index++]=spdv->GetXv();
580 xnt[index++]=spdv->GetXRes();
581 xnt[index++]=spdv->GetYv();
582 xnt[index++]=spdv->GetYRes();
583 xnt[index++]=spdv->GetZv();
584 xnt[index++]=spdv->GetZRes();
585 xnt[index++]=spdv->GetNContributors();
8c7764e0 586 TString spdtitle = spdv->GetTitle();
587 xnt[index++]=(spdtitle.Contains("vertexer: 3D") ? 1. : 0.);
588 xnt[index++]=spdv->GetDispersion();
388ca814 589
97805f7d 590 xnt[index++]=tpcv->GetXv();
591 xnt[index++]=tpcv->GetXRes();
592 xnt[index++]=tpcv->GetYv();
593 xnt[index++]=tpcv->GetYRes();
594 xnt[index++]=tpcv->GetZv();
595 xnt[index++]=tpcv->GetZRes();
596 xnt[index++]=tpcv->GetNContributors();
8c7764e0 597 TString tpctitle = tpcv->GetTitle();
598 xnt[index++]=(tpctitle.Contains("WithConstraint") ? 1. : 0.);
388ca814 599
97805f7d 600 xnt[index++]=trkv->GetXv();
601 xnt[index++]=trkv->GetXRes();
602 xnt[index++]=trkv->GetYv();
603 xnt[index++]=trkv->GetYRes();
604 xnt[index++]=trkv->GetZv();
605 xnt[index++]=trkv->GetZRes();
606 xnt[index++]=trkv->GetNContributors();// tpccontrorig;
8c7764e0 607 TString trktitle = trkv->GetTitle();
608 xnt[index++]=(trktitle.Contains("WithConstraint") ? 1. : 0.);
388ca814 609
97805f7d 610 xnt[index++]=float(ntrklets);
30b05a14 611 secnt[indexSecNt++]=float(ntrklets);
4f0574ad 612 ntrkletsS = (UShort_t)ntrklets;
30b05a14 613
97805f7d 614 xnt[index++]=float(ntracks);
615 xnt[index++]=float(nITS5or6);
30b05a14 616
97805f7d 617 xnt[index++]=float(nTPCin);
618 xnt[index++]=float(nTPCinEta09);
388ca814 619
97805f7d 620 xnt[index++]=spd0cls;
68d70d53 621
622 xnt[index++]=Float_t(isPileUpfromSPD);
39258194 623 xnt[index++]=xpile;
624 xnt[index++]=expile;
625 xnt[index++]=ypile;
626 xnt[index++]=eypile;
627 xnt[index++]=zpile;
628 xnt[index++]=ezpile;
629 xnt[index++]=(Float_t)ntrkspile;
630
631
632
8c7764e0 633 // add recalculated vertices TRK and TPC
97805f7d 634
8c7764e0 635 if(fRecoVtxTPC) {
636 AliESDVertex *tpcvnc = ReconstructPrimaryVertexTPC(kFALSE);
637 xnt[index++]=tpcvnc->GetXv();
638 xnt[index++]=tpcvnc->GetXRes();
639 xnt[index++]=tpcvnc->GetYv();
640 xnt[index++]=tpcvnc->GetYRes();
641 xnt[index++]=tpcvnc->GetZv();
642 xnt[index++]=tpcvnc->GetZRes();
643 xnt[index++]=tpcvnc->GetNContributors();
644 delete tpcvnc; tpcvnc=0;
645
646 AliESDVertex *tpcvc = ReconstructPrimaryVertexTPC(kTRUE);
647 xnt[index++]=tpcvc->GetXv();
648 xnt[index++]=tpcvc->GetXRes();
649 xnt[index++]=tpcvc->GetYv();
650 xnt[index++]=tpcvc->GetYRes();
651 xnt[index++]=tpcvc->GetZv();
652 xnt[index++]=tpcvc->GetZRes();
653 xnt[index++]=tpcvc->GetNContributors();
654 delete tpcvc; tpcvc=0;
39258194 655 } else index+=14;
8c7764e0 656
657 if(fRecoVtxITSTPC) {
658 AliESDVertex *trkvnc = ReconstructPrimaryVertexITSTPC(kFALSE);
659 xnt[index++]=trkvnc->GetXv();
660 xnt[index++]=trkvnc->GetXRes();
661 xnt[index++]=trkvnc->GetYv();
662 xnt[index++]=trkvnc->GetYRes();
663 xnt[index++]=trkvnc->GetZv();
664 xnt[index++]=trkvnc->GetZRes();
665 xnt[index++]=trkvnc->GetNContributors();
30b05a14 666
667 secnt[indexSecNt++]=trkvnc->GetXv();
668 secnt[indexSecNt++]=trkvnc->GetYv();
669 secnt[indexSecNt++]=trkvnc->GetZv();
670 secnt[indexSecNt++]=trkvnc->GetNContributors();
4f0574ad 671
672 xTRKnc = (Float_t)trkvnc->GetXv();
673 yTRKnc = (Float_t)trkvnc->GetYv();
674 zTRKnc = (Float_t)trkvnc->GetZv();
ee98f8eb 675 ntrksTRKnc = (trkvnc->GetNContributors()<0 ? 0 : (UShort_t)trkvnc->GetNContributors());
4f0574ad 676
30b05a14 677 delete trkvnc; trkvnc=0;
678
679
8c7764e0 680 AliESDVertex *trkvc = ReconstructPrimaryVertexITSTPC(kTRUE);
681 xnt[index++]=trkvc->GetXv();
682 xnt[index++]=trkvc->GetXRes();
683 xnt[index++]=trkvc->GetYv();
684 xnt[index++]=trkvc->GetYRes();
685 xnt[index++]=trkvc->GetZv();
686 xnt[index++]=trkvc->GetZRes();
687 xnt[index++]=trkvc->GetNContributors();
688 delete trkvc; trkvc=0;
39258194 689 } else index+=14;
690
4d95fd6c 691 if(fRecoVtxITSTPCHalfEvent) {
692 AliESDVertex *trkvncodd = ReconstructPrimaryVertexITSTPC(kFALSE,1);
693 AliESDVertex *trkvnceven = ReconstructPrimaryVertexITSTPC(kFALSE,2);
694 if(trkvncodd->GetNContributors()>0 &&
695 trkvnceven->GetNContributors()>0) {
696 xnt[index++]=trkvncodd->GetXv()-trkvnceven->GetXv();
4d95fd6c 697 xnt[index++]=trkvncodd->GetYv()-trkvnceven->GetYv();
4d95fd6c 698 xnt[index++]=trkvncodd->GetZv()-trkvnceven->GetZv();
007ec307 699 xnt[index++]=TMath::Sqrt(trkvncodd->GetXRes()*trkvncodd->GetXRes()+trkvnceven->GetXRes()*trkvnceven->GetXRes());
700 xnt[index++]=TMath::Sqrt(trkvncodd->GetYRes()*trkvncodd->GetYRes()+trkvnceven->GetYRes()*trkvnceven->GetYRes());
4d95fd6c 701 xnt[index++]=TMath::Sqrt(trkvncodd->GetZRes()*trkvncodd->GetZRes()+trkvnceven->GetZRes()*trkvnceven->GetZRes());
19076e2d 702 xnt[index++]=trkvnceven->GetNContributors();
703 xnt[index++]=trkvncodd->GetNContributors();
4d95fd6c 704 } else {
705 xnt[index++]=0.;
706 xnt[index++]=0.;
707 xnt[index++]=0.;
708 xnt[index++]=0.;
709 xnt[index++]=0.;
710 xnt[index++]=0.;
711 xnt[index++]=-1;
19076e2d 712 xnt[index++]=-1;
4d95fd6c 713 }
714 delete trkvncodd; trkvncodd=0;
715 delete trkvnceven; trkvnceven=0;
19076e2d 716 } else index+=8;
4d95fd6c 717
718
8c7764e0 719 if(index>isize) printf("AliAnalysisTaskVertexESD: ERROR, index!=isize\n");
b588553c 720 if(fFillNtuple) fNtupleVertexESD->Fill(xnt);
30b05a14 721
722 if(indexSecNt>isizeSecNt) printf("AliAnalysisTaskVertexESD: ERROR, indexSecNt!=isizeSecNt\n");
4f0574ad 723
724 // if(indexTree>isizeTree) printf("AliAnalysisTaskVertexESD: ERROR, indexTree!=isizeTree\n");
725 // only every second event (to reduce output size)
726 if(fFillTreeBeamSpot && (nInFile%2 == 0)) fTreeBeamSpot->Fill();
727
f6232e6e 728
388ca814 729 // Post the data already here
41deb8e3 730 PostData(1, fOutput);
388ca814 731
732 return;
733}
734
735//________________________________________________________________________
736void AliAnalysisTaskVertexESD::Terminate(Option_t *)
737{
738 // Draw result to the screen
739 // Called once at the end of the query
2ac70243 740 fOutput = dynamic_cast<TList*> (GetOutputData(1));
388ca814 741 if (!fOutput) {
742 Printf("ERROR: fOutput not available");
743 return;
744 }
30b05a14 745
a874bb01 746 //////////////////////////////////////////////////////
747 /*
748 TH1F *fhTriggeredTrklets=(TH1F*)fOutput->FindObject("fhTriggeredTrklets");
749 TH1F *fhSPDZTrklets=(TH1F*)fOutput->FindObject("fhSPDZTrklets");
750 TH1F *fhSPD3DTrklets=(TH1F*)fOutput->FindObject("fhSPD3DTrklets");
751 TH1F *fhTRKTrklets=(TH1F*)fOutput->FindObject("fhTRKTrklets");
752 TH1F *fhTRKcTrklets=(TH1F*)fOutput->FindObject("fhTRKcTrklets");
753 TH1F *fhTRKncTrklets=(TH1F*)fOutput->FindObject("fhTRKncTrklets");
754 TH1F *fhSPDZZreco=(TH1F*)fOutput->FindObject("fhSPDZZreco");
755 TH1F *fhSPD3DZreco=(TH1F*)fOutput->FindObject("fhSPD3DZreco");
756
757 TGraphAsymmErrors *fhSPDZEffTrklets=new TGraphAsymmErrors(fhSPDZTrklets,fhTriggeredTrklets,"w");
758 fhSPDZEffTrklets->SetName("fhSPDZEffTrklets");
759 fhSPDZEffTrklets->SetDrawOption("AP");
760 TGraphAsymmErrors *fhSPD3DEffTrklets=new TGraphAsymmErrors(fhSPD3DTrklets,fhTriggeredTrklets,"w");
761 fhSPD3DEffTrklets->SetName("fhSPD3DEffTrklets");
762 TH1F * fhSPDOverallTrklets=(TH1F*)fhSPDZTrklets->Clone("fhSPDOverallTrklets");
763 fhSPDOverallTrklets->Add(fhSPD3DTrklets);
764 TGraphAsymmErrors *fhSPDOverallEffTrklets=new TGraphAsymmErrors(fhSPDOverallTrklets,fhTriggeredTrklets,"w");
765 fhSPDOverallEffTrklets->SetName("fhSPDOverallEffTrklets");
766 TGraphAsymmErrors *fhTRKEffTrklets=new TGraphAsymmErrors(fhTRKTrklets,fhTriggeredTrklets,"w");
767 fhTRKEffTrklets->SetName("fhTRKEffTrklets");
768 TGraphAsymmErrors *fhTRKcEffTrklets=new TGraphAsymmErrors(fhTRKcTrklets,fhTriggeredTrklets,"w");
769 fhTRKcEffTrklets->SetName("fhTRKcEffTrklets");
770 TGraphAsymmErrors *fhTRKncEffTrklets=new TGraphAsymmErrors(fhTRKncTrklets,fhTriggeredTrklets,"w");
771 fhTRKncEffTrklets->SetName("fhTRKncEffTrklets");
772 TH1F * fhSPDOverallZreco=(TH1F*)fhSPDZZreco->Clone("fhSPDOverallZreco");
773 fhSPDOverallZreco->Add(fhSPD3DZreco);
774 TGraphAsymmErrors *fhSPDEffZreco=new TGraphAsymmErrors(fhSPD3DZreco,fhSPDOverallZreco,"w");
775 fhSPDEffZreco->SetName("fhSPDEffZreco");
776
777 TH1F *fhEff = new TH1F("hEff","hEff",6,0.5,6.5);
778 Int_t count=1;
779 if(fhSPDZTrklets->GetEntries()!=0 && fhTriggeredTrklets->GetEntries()!=0){
780 fhEff->Fill(count,fhSPDZTrklets->GetEntries()/fhTriggeredTrklets->GetEntries());
781 fhEff->SetBinError(count,fhEff->GetBinContent(count)*TMath::Sqrt(1/fhSPDZTrklets->GetEntries()+1/fhTriggeredTrklets->GetEntries()));
782 }
783 fhEff->GetXaxis()->SetBinLabel(count,"SPDZ");
784
785 count++;
786 if(fhSPD3DTrklets->GetEntries()!=0 && fhTriggeredTrklets->GetEntries()!=0){
787 fhEff->Fill(count,fhSPD3DTrklets->GetEntries()/fhTriggeredTrklets->GetEntries());
788 fhEff->SetBinError(count,fhEff->GetBinContent(count)*TMath::Sqrt(1/fhSPD3DTrklets->GetEntries()+1/fhTriggeredTrklets->GetEntries()));
789 }
790 fhEff->GetXaxis()->SetBinLabel(count,"SPD3D");
791
792 count++;
793 if(fhSPDOverallTrklets->GetEntries()!=0 && fhTriggeredTrklets->GetEntries()!=0){
794 fhEff->Fill(count,fhSPDOverallTrklets->GetEntries()/fhTriggeredTrklets->GetEntries());
795 fhEff->SetBinError(count,fhEff->GetBinContent(count)*TMath::Sqrt(1/fhSPDOverallTrklets->GetEntries()+1/fhTriggeredTrklets->GetEntries()));
796 }
797 fhEff->GetXaxis()->SetBinLabel(count,"SPD Overall");
798
799 count++;
800 if(fhTRKTrklets->GetEntries()!=0 && fhTriggeredTrklets->GetEntries()!=0){
801 fhEff->Fill(count,fhTRKTrklets->GetEntries()/fhTriggeredTrklets->GetEntries());
802 fhEff->SetBinError(count,fhEff->GetBinContent(count)*TMath::Sqrt(1/fhTRKTrklets->GetEntries()+1/fhTriggeredTrklets->GetEntries()));
803 }
804 fhEff->GetXaxis()->SetBinLabel(count,"TRK");
805
806 count++;
807 if(fhTRKcTrklets->GetEntries()!=0 && fhTriggeredTrklets->GetEntries()!=0){
808 fhEff->Fill(count,fhTRKcTrklets->GetEntries()/fhTriggeredTrklets->GetEntries());
809 fhEff->SetBinError(count,fhEff->GetBinContent(count)*TMath::Sqrt(1/fhTRKcTrklets->GetEntries()+1/fhTriggeredTrklets->GetEntries()));
810 }
811 fhEff->GetXaxis()->SetBinLabel(count,"TRKc");
812
813 count++;
814 if(fhTRKncTrklets->GetEntries()!=0 && fhTriggeredTrklets->GetEntries()!=0){
815 fhEff->Fill(count,fhTRKncTrklets->GetEntries()/fhTriggeredTrklets->GetEntries());
816 fhEff->SetBinError(count,fhEff->GetBinContent(count)*TMath::Sqrt(1/fhTRKncTrklets->GetEntries()+1/fhTriggeredTrklets->GetEntries()));
817 }
818 fhEff->GetXaxis()->SetBinLabel(count,"TRKnc");
819
820 count++;
821 fhEff->Print("all");
822
823 TFile* fileEff = new TFile("VtxEff.root","recreate");
824 fhSPDZEffTrklets->Write();
825 fhSPD3DEffTrklets->Write();
826 fhSPDOverallEffTrklets->Write();
827 fhTRKEffTrklets->Write();
828 fhTRKcEffTrklets->Write();
829 fhTRKncEffTrklets->Write();
830 fhSPDEffZreco->Write();
831 fhEff->Write();
832 fileEff->Close();
833 delete fileEff;
834
835 /////////////////////////////////////////
836 */
837
838
30b05a14 839 if (!fNtupleVertexESD){
840 Printf("ERROR: fNtuple not available");
841 return;
842 }
843
388ca814 844 fNtupleVertexESD = dynamic_cast<TNtuple*>(fOutput->FindObject("fNtupleVertexESD"));
845
30b05a14 846
388ca814 847 return;
848}
849
850//_________________________________________________________________________
8c7764e0 851AliESDVertex* AliAnalysisTaskVertexESD::ReconstructPrimaryVertexTPC(Bool_t constr) const {
388ca814 852 // On the fly reco of TPC vertex from ESD
74917c1f 853 AliESDEvent* evt = (AliESDEvent*) fInputEvent;
854 AliVertexerTracks vertexer(evt->GetMagneticField());
0faeb7ba 855 if(evt->GetNumberOfTracks()<500) {
856 vertexer.SetTPCMode(); // defaults
857 } else {
858 vertexer.SetTPCMode(0.1,1.0,5.0,10,1,3.,0.1,1.5,3.,30.,1,1);// PbPb
859 }
8c7764e0 860 Float_t diamondcovxy[3]; evt->GetDiamondCovXY(diamondcovxy);
861 Double_t pos[3]={evt->GetDiamondX(),evt->GetDiamondY(),0};
862 Double_t cov[6]={diamondcovxy[0],diamondcovxy[1],diamondcovxy[2],0.,0.,10.*10.};
863 AliESDVertex *initVertex = new AliESDVertex(pos,cov,1.,1);
388ca814 864 vertexer.SetVtxStart(initVertex);
865 delete initVertex;
8c7764e0 866 if(!constr) vertexer.SetConstraintOff();
388ca814 867
74917c1f 868 return vertexer.FindPrimaryVertex(evt);
388ca814 869}
94f15f9b 870
871//_________________________________________________________________________
4d95fd6c 872AliESDVertex* AliAnalysisTaskVertexESD::ReconstructPrimaryVertexITSTPC(Bool_t constr,Int_t mode) const {
94f15f9b 873 // On the fly reco of ITS+TPC vertex from ESD
4d95fd6c 874 // mode=0 use all tracks
875 // mode=1 use odd-number tracks
876 // mode=2 use even-number tracks
877
74917c1f 878 AliESDEvent* evt = (AliESDEvent*) fInputEvent;
879 AliVertexerTracks vertexer(evt->GetMagneticField());
0faeb7ba 880 if(evt->GetNumberOfTracks()<500) {
881 vertexer.SetITSMode(); // defaults
93fd62e4 882 vertexer.SetMinClusters(3); // default is 5
0faeb7ba 883 } else {
884 vertexer.SetITSMode(0.1,0.1,0.5,5,1,3.,100.,1000.,3.,30.,1,1);// PbPb
885 }
30b05a14 886 //vertexer.SetITSpureSA();
8c7764e0 887 Float_t diamondcovxy[3]; evt->GetDiamondCovXY(diamondcovxy);
888 Double_t pos[3]={evt->GetDiamondX(),evt->GetDiamondY(),0};
889 Double_t cov[6]={diamondcovxy[0],diamondcovxy[1],diamondcovxy[2],0.,0.,10.*10.};
890 AliESDVertex *initVertex = new AliESDVertex(pos,cov,1.,1);
94f15f9b 891 vertexer.SetVtxStart(initVertex);
892 delete initVertex;
8c7764e0 893 if(!constr) vertexer.SetConstraintOff();
94f15f9b 894
cb393b39 895 // use only ITS-TPC or only ITS-SA tracks
5457d525 896 if(fOnlyITSTPCTracks || fOnlyITSSATracks || mode>0) {
cb393b39 897 Int_t iskip=0;
74917c1f 898 Int_t *skip = new Int_t[evt->GetNumberOfTracks()];
899 for(Int_t itr=0;itr<evt->GetNumberOfTracks(); itr++) {
900 AliESDtrack* track = evt->GetTrack(itr);
cb393b39 901 if(fOnlyITSTPCTracks && track->GetNcls(1)==0) { // skip ITSSA
902 skip[iskip++]=itr;
4d95fd6c 903 continue;
cb393b39 904 }
905 if(fOnlyITSSATracks && track->GetNcls(1)>0) { // skip ITSTPC
906 skip[iskip++]=itr;
4d95fd6c 907 continue;
cb393b39 908 }
4d95fd6c 909 if(mode==1 && itr%2==0) skip[iskip++]=itr;
910 if(mode==2 && itr%2==1) skip[iskip++]=itr;
cb393b39 911 }
912 vertexer.SetSkipTracks(iskip,skip);
913 delete [] skip; skip=NULL;
914 }
915
74917c1f 916 return vertexer.FindPrimaryVertex(evt);
94f15f9b 917}