]>
Commit | Line | Data |
---|---|---|
a0b94e5c | 1 | #ifndef ALIV0READER_H |
2 | #define ALIV0READER_H | |
3 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
4 | * See cxx source for full Copyright notice */ | |
5 | ||
6 | //////////////////////////////////////////////// | |
7 | //--------------------------------------------- | |
8 | // Class used to do analysis on conversion pairs | |
9 | //--------------------------------------------- | |
10 | //////////////////////////////////////////////// | |
11 | ||
12 | // --- ROOT system --- | |
13 | #include "TObject.h" | |
14 | #include "AliMCEvent.h" // for CF | |
15 | #include "AliESDv0.h" | |
16 | #include "AliESDEvent.h" | |
17 | #include "AliKFParticle.h" | |
18 | #include "TParticle.h" | |
19 | #include "AliGammaConversionHistograms.h" | |
20 | #include <vector> | |
21 | #include "AliCFManager.h" | |
5e55d806 | 22 | #include "AliGammaConversionBGHandler.h" |
a0b94e5c | 23 | |
24 | class TClonesArray; | |
25 | class TFormula; | |
26 | class Riostream; | |
27 | class TChain; | |
28 | ||
29 | //--- AliRoot system --- | |
30 | ||
31 | class AliStack; | |
32 | class AliMCEvent; // for CF | |
33 | class AliESDEvent; | |
34 | class AliMCEventHandler; | |
35 | class AliESDInputHandler; | |
36 | class AliESDVertex; | |
37 | class AliLog; | |
38 | class TChain; | |
39 | class TChain; | |
40 | class AliCFManager; // for CF | |
41 | class AliCFContainer; // for CF | |
10d100d4 | 42 | class AliESDpid; // for dEdx cut based on nSigma to particle lines |
037dc2db | 43 | class AliESDtrackCuts; |
a0b94e5c | 44 | |
45 | class AliV0Reader : public TObject { | |
46 | ||
47 | public: | |
48 | ||
49 | ||
50 | // for CF | |
51 | enum{ | |
52 | kStepGenerated = 0, | |
53 | kStepReconstructable = 1, | |
ebcfaa7e | 54 | kStepGetOnFly = 2, |
55 | kStepLikeSign = 3, | |
56 | kStepTPCRefit = 4, | |
57 | kStepKinks = 5, | |
58 | kStepdEdx_electronselection = 6, | |
59 | kStepdEdx_pionrejection = 7, | |
60 | kStepNContributors = 8, | |
61 | kStepTPCPID = 9, | |
62 | kStepR = 10, | |
63 | kStepLine = 11, | |
64 | kStepZ = 12, | |
65 | kStepNDF = 13, | |
66 | kStepChi2 = 14, | |
67 | kStepEta = 15, | |
68 | kStepPt = 16, | |
69 | kStepTrueGamma = 17 | |
a0b94e5c | 70 | }; |
71 | ||
a0b94e5c | 72 | AliV0Reader(); //constructor |
73 | AliV0Reader(const AliV0Reader & g); //copy constructor | |
74 | AliV0Reader & operator = (const AliV0Reader & g); //assignment operator | |
9640a3d1 | 75 | // virtual ~AliV0Reader() {;} //virtual destructor |
76 | virtual ~AliV0Reader(); //virtual destructor | |
a0b94e5c | 77 | /* |
78 | *Initialize the reader | |
79 | */ | |
80 | void Initialize(); | |
81 | ||
82 | ||
83 | // for CF | |
4a6157dc | 84 | void SetCFManager(AliCFManager * const io){fCFManager = io;}; |
a0b94e5c | 85 | AliCFManager *GetCFManager() const {return fCFManager;} |
86 | ||
87 | ||
88 | ||
89 | ||
90 | /* | |
91 | * Returns AliESDEvent | |
92 | */ | |
93 | AliESDEvent* GetESDEvent() const{return fESDEvent;} | |
94 | ||
95 | /* | |
96 | *Returns the number of v0s in the event, no cuts applied. | |
97 | */ | |
98 | Int_t GetNumberOfV0s() const{return fESDEvent->GetNumberOfV0s();} | |
99 | ||
b5832f95 | 100 | /* |
101 | *Returns the number of contributors to the vertex | |
102 | */ | |
103 | Int_t GetNumberOfContributorsVtx() const{return fESDEvent->GetPrimaryVertex()->GetNContributors();} | |
104 | ||
a0b94e5c | 105 | /* |
106 | * Check if there are any more good v0s left in the v0 stack | |
107 | * if so, fCurrent v0 is set to this v0 and can be retrieved | |
108 | * by GetCurrentV0 function. | |
109 | * returns kFALSE if there is no more good v0s in the v0 stack | |
110 | */ | |
111 | Bool_t NextV0(); | |
112 | ||
113 | /* | |
114 | * Returns the v0 at the given index, no checks are done on the v0. | |
115 | */ | |
116 | AliESDv0* GetV0(Int_t index); | |
117 | ||
118 | /* | |
119 | * Returns the current v0 | |
120 | */ | |
121 | AliESDv0* GetCurrentV0() const{return fCurrentV0;} | |
122 | ||
123 | /* | |
124 | * Returns the negative ESD track which belongs to fCurrentV0 | |
125 | */ | |
126 | AliESDtrack* GetNegativeESDTrack(){return fESDEvent->GetTrack(fCurrentV0->GetNindex());} | |
127 | ||
128 | /* | |
129 | * Returns the positive ESD track which belongs to fCurrentV0 | |
130 | */ | |
131 | AliESDtrack* GetPositiveESDTrack(){return fESDEvent->GetTrack(fCurrentV0->GetPindex());} | |
132 | ||
133 | /* | |
134 | * Returns the negative KF particle which belongs to fCurrentV0 | |
135 | */ | |
136 | AliKFParticle* GetNegativeKFParticle() const{return fCurrentNegativeKFParticle;} | |
137 | ||
138 | /* | |
139 | * Returns the positive KF particle which belongs to fCurrentV0 | |
140 | */ | |
141 | AliKFParticle* GetPositiveKFParticle() const{return fCurrentPositiveKFParticle;} | |
142 | ||
143 | /* | |
144 | * Returns the KFParticle object of the 2 tracks. | |
145 | */ | |
146 | AliKFParticle* GetMotherCandidateKFCombination() const{return fCurrentMotherKFCandidate;} | |
147 | ||
148 | /* | |
149 | * Checks the probablity that the PID of the particle is what we want it to be. | |
150 | */ | |
151 | Bool_t CheckPIDProbability(Double_t negProbCut, Double_t posProbCut); | |
152 | ||
153 | /* | |
154 | * Checks if the PID of the two particles are within our cuts. | |
155 | */ | |
156 | void GetPIDProbability(Double_t &negPIDProb, Double_t &posPIDProb); | |
157 | ||
158 | /* | |
159 | *Get the negative MC TParticle from the stack | |
160 | */ | |
161 | TParticle * GetNegativeMCParticle() const{return fNegativeMCParticle;} | |
162 | ||
163 | /* | |
164 | *Get the positive MC TParticle from the stack | |
165 | */ | |
166 | TParticle * GetPositiveMCParticle() const{return fPositiveMCParticle;} | |
167 | ||
168 | /* | |
169 | *Get the mother MC TParticle from the stack | |
170 | */ | |
171 | TParticle * GetMotherMCParticle() const{return fMotherMCParticle;} | |
172 | ||
173 | /* | |
174 | * Flag to see if the v0 particles share the same mother | |
175 | */ | |
176 | Bool_t HasSameMCMother(); | |
177 | ||
178 | ||
179 | /* | |
180 | *Get the PID of the MC mother particle | |
181 | */ | |
182 | Int_t GetMotherMCParticlePDGCode() const{if(fMotherMCParticle != NULL){ cout<<"MCParticle exists"<<endl;} return fMotherMCParticle->GetPdgCode();} | |
183 | ||
184 | /* | |
185 | *Get the MC stack | |
186 | */ | |
187 | AliStack* GetMCStack() const{return fMCStack;} | |
188 | ||
189 | ||
190 | /* | |
191 | * Setup AliMCEventHandler | |
192 | */ | |
193 | AliMCEventHandler* GetMCTruth() const{return fMCTruth;} // for CF | |
194 | ||
195 | ||
196 | /* | |
197 | *Get the MC stack | |
198 | */ | |
199 | AliMCEvent* GetMCEvent() const{return fMCEvent;} // for CF | |
200 | ||
201 | ||
202 | /* | |
203 | *Get the magnetic field from the ESD event | |
204 | */ | |
205 | Double_t GetMagneticField() const{return fESDEvent->GetMagneticField();} | |
206 | ||
207 | /* | |
208 | *Get the primary vertex from the esd event | |
209 | */ | |
210 | const AliESDVertex *GetPrimaryVertex() const {return fESDEvent->GetPrimaryVertex();} | |
211 | ||
212 | /* | |
213 | * Set the PID of the negative track | |
214 | */ | |
215 | void SetNegativeTrackPID(Int_t negTrackPID){fNegativeTrackPID=negTrackPID;} | |
216 | ||
217 | /* | |
218 | * Set the PID of the positive track | |
219 | */ | |
220 | void SetPositiveTrackPID(Int_t posTrackPID){fPositiveTrackPID=posTrackPID;} | |
221 | ||
222 | /* | |
223 | * Set the flag to use the kfparticle class. Will also disable the use of esd tracks | |
224 | */ | |
225 | void UseKFParticle(){fUseKFParticle = kTRUE; fUseESDTrack = kFALSE;} | |
226 | ||
227 | /* | |
228 | * Set the flag to use the esd track class. Will also disable the use of kf particles | |
229 | */ | |
230 | void UseESDTrack(){fUseESDTrack = kTRUE; fUseKFParticle = kFALSE;} | |
231 | ||
232 | /* | |
233 | * Set the flag to use improved vertex or not | |
234 | */ | |
235 | void SetUseImprovedVertex(Bool_t useImprovedVertex){fUseImprovedVertex=useImprovedVertex;} | |
236 | ||
237 | /* | |
238 | * Return the number in the species array belonging to the negative or positive track pid. | |
239 | */ | |
240 | Int_t GetSpeciesIndex(Int_t chargeOfTrack); | |
241 | ||
242 | /* | |
243 | * Return the x coordinate of the v0 | |
244 | */ | |
245 | Double_t GetX() const{return fCurrentXValue;} | |
246 | ||
247 | /* | |
248 | * Return the y coordinate of the v0 | |
249 | */ | |
250 | Double_t GetY() const{return fCurrentYValue;} | |
251 | ||
252 | /* | |
253 | * Return the Z coordinate of the v0 | |
254 | */ | |
255 | Double_t GetZ() const{return fCurrentZValue;} | |
256 | ||
257 | /* | |
258 | * Return the radius of the v0 | |
259 | */ | |
260 | Double_t GetXYRadius() const{return sqrt((Double_t)(fCurrentXValue*fCurrentXValue + fCurrentYValue*fCurrentYValue));} | |
261 | ||
262 | /* | |
263 | * Get the opening angle between the two tracks | |
264 | */ | |
265 | Double_t GetOpeningAngle(){return fNegativeTrackLorentzVector->Angle(fPositiveTrackLorentzVector->Vect());} | |
9640a3d1 | 266 | |
267 | /* | |
268 | * Get the Cos Pointing angle between the two tracks | |
269 | */ | |
270 | Double_t GetCosPointingAngle(){return fCurrentV0->GetV0CosineOfPointingAngle();} | |
271 | ||
272 | /* | |
273 | * Get the DCA between the two tracks | |
274 | */ | |
275 | Double_t GetDcaDaughters(){return fCurrentV0->GetDcaV0Daughters();} | |
276 | ||
277 | /* | |
278 | * Get the Normalized DCA between the two tracks | |
279 | */ | |
280 | Double_t GetNormDcaDistDaughters(){return fCurrentV0->GetDcaV0Daughters()/fCurrentV0->GetDistSigma();} | |
281 | ||
282 | /* | |
283 | * Get the Likelihood for a Conversion | |
284 | */ | |
285 | Double_t GetLikelihoodAP(){return fCurrentV0->GetLikelihoodAP(0,0);} | |
286 | ||
a0b94e5c | 287 | /* |
288 | * Gets the Energy of the negative track. | |
289 | */ | |
290 | Double_t GetNegativeTrackEnergy() const{return fCurrentNegativeKFParticle->E();} | |
291 | ||
292 | /* | |
293 | * Gets the Energy of the positive track. | |
294 | */ | |
295 | Double_t GetPositiveTrackEnergy() const{return fCurrentPositiveKFParticle->E();} | |
296 | ||
297 | /* | |
298 | * Gets the Energy of the mother candidate. | |
299 | */ | |
300 | Double_t GetMotherCandidateEnergy() const{return fCurrentMotherKFCandidate->E();} | |
301 | ||
302 | /* | |
303 | * Gets the Pt of the negative track. | |
304 | */ | |
305 | Double_t GetNegativeTrackPt() const{return fNegativeTrackLorentzVector->Pt();} | |
306 | ||
307 | /* | |
308 | * Gets the Pt of the positive track. | |
309 | */ | |
310 | Double_t GetPositiveTrackPt() const{return fPositiveTrackLorentzVector->Pt();} | |
311 | ||
9640a3d1 | 312 | |
a0b94e5c | 313 | /* |
314 | * Gets the Pt of the mother candidate. | |
315 | */ | |
316 | Double_t GetMotherCandidatePt() const{return fMotherCandidateLorentzVector->Pt();} | |
9640a3d1 | 317 | |
318 | ||
319 | /* | |
320 | * Gets the P of the mother candidate. | |
321 | */ | |
322 | Double_t GetMotherCandidateP() const{return fMotherCandidateLorentzVector->P();} | |
a0b94e5c | 323 | |
9640a3d1 | 324 | |
a0b94e5c | 325 | /* |
326 | * Gets the Eta of the negative track. | |
327 | */ | |
328 | Double_t GetNegativeTrackEta() const{return fNegativeTrackLorentzVector->Eta();} | |
329 | /* | |
330 | * Gets the Eta of the positive track. | |
331 | */ | |
332 | Double_t GetPositiveTrackEta() const{return fPositiveTrackLorentzVector->Eta();} | |
333 | /* | |
334 | * Gets the Eta of the mother candidate. | |
335 | */ | |
336 | Double_t GetMotherCandidateEta() const{return fMotherCandidateLorentzVector->Eta();} | |
337 | ||
338 | /* | |
339 | * Gets the NDF of the mother candidate. | |
340 | */ | |
341 | Double_t GetMotherCandidateNDF() const{return fCurrentMotherKFCandidate->GetNDF();} | |
342 | ||
343 | /* | |
344 | * Gets the Chi2 of the mother candidate. | |
345 | */ | |
346 | Double_t GetMotherCandidateChi2() const{return fCurrentMotherKFCandidate->GetChi2();} | |
347 | ||
348 | /* | |
349 | * Gets the Mass of the mother candidate. | |
350 | */ | |
351 | Double_t GetMotherCandidateMass() const{return fMotherCandidateKFMass;} | |
352 | ||
353 | /* | |
354 | * Gets the Width of the mother candidate. | |
355 | */ | |
356 | Double_t GetMotherCandidateWidth() const{return fMotherCandidateKFWidth;} | |
357 | ||
358 | /* | |
359 | * Gets the Phi of the negative track. | |
360 | */ | |
361 | Double_t GetNegativeTrackPhi() const; | |
362 | ||
363 | /* | |
364 | * Gets the Phi of the positive track. | |
365 | */ | |
366 | Double_t GetPositiveTrackPhi() const; | |
367 | ||
368 | /* | |
369 | * Gets the Phi of the mother candidate. | |
370 | */ | |
371 | Double_t GetMotherCandidatePhi() const; | |
372 | ||
373 | /* | |
374 | * Gets the Rapidity of the mother candidate. | |
375 | */ | |
376 | Double_t GetMotherCandidateRapidity() const; | |
377 | ||
9640a3d1 | 378 | |
379 | /* | |
380 | * Gets the P of the negative track. | |
381 | */ | |
382 | Double_t GetNegativeTrackP() const{return fNegativeTrackLorentzVector->P();} | |
383 | ||
384 | /* | |
385 | * Gets the P of the positive track. | |
386 | */ | |
387 | Double_t GetPositiveTrackP() const{return fPositiveTrackLorentzVector->P();} | |
388 | ||
389 | /* | |
390 | * Gets the dE/dx in the TPC of the negative track. | |
391 | */ | |
392 | Double_t GetNegativeTrackTPCdEdx() const{return fCurrentNegativeESDTrack->GetTPCsignal();} | |
393 | ||
394 | /* | |
395 | * Gets the dE/dx in the TPC of the positive track. | |
396 | */ | |
397 | Double_t GetPositiveTrackTPCdEdx() const{return fCurrentPositiveESDTrack->GetTPCsignal();} | |
ebcfaa7e | 398 | |
399 | /* | |
400 | * Gets the Number of the TPC clusters of the negative track. | |
401 | */ | |
402 | Double_t GetNegativeTracknTPCClusters() const{return fCurrentNegativeESDTrack->GetNcls(1);} | |
403 | ||
404 | /* | |
405 | * Gets the Number of the TPC clusters of the positive track. | |
406 | */ | |
407 | Double_t GetPositiveTracknTPCClusters() const{return fCurrentPositiveESDTrack->GetNcls(1);} | |
408 | ||
409 | /* | |
410 | * Gets the Number of the ITS clusters of the negative track. | |
411 | */ | |
412 | Double_t GetNegativeTracknITSClusters() const{return fCurrentNegativeESDTrack->GetNcls(0);} | |
413 | ||
414 | /* | |
415 | * Gets the Number of the ITS clusters of the positive track. | |
416 | */ | |
417 | Double_t GetPositiveTracknITSClusters() const{return fCurrentPositiveESDTrack->GetNcls(0);} | |
a0b94e5c | 418 | |
419 | /* | |
420 | * Update data which need to be updated every event. | |
421 | */ | |
422 | void UpdateEventByEventData(); | |
423 | ||
424 | /* | |
425 | * Gets the MaxRCut value. | |
426 | */ | |
427 | Double_t GetMaxRCut() const{return fMaxR;} | |
428 | ||
429 | /* | |
430 | * Gets the Eta cut value. | |
431 | */ | |
432 | Double_t GetEtaCut() const{return fEtaCut;} | |
433 | ||
434 | /* | |
435 | * Gets the Pt cut value. | |
436 | */ | |
437 | Double_t GetPtCut() const{return fPtCut;} | |
438 | ||
439 | ||
440 | /* | |
441 | * Gets the MaxZCut value. | |
442 | */ | |
443 | Double_t GetMaxZCut() const{return fMaxZ;} | |
444 | ||
445 | ||
446 | /* | |
447 | * Gets the line cut values. | |
448 | */ | |
449 | Double_t GetLineCutZRSlope() const{return fLineCutZRSlope;} | |
450 | Double_t GetLineCutZValue() const{return fLineCutZValue;} | |
451 | ||
452 | /* | |
453 | * Gets the Chi2 cut value for the conversions. | |
454 | */ | |
455 | Double_t GetChi2CutConversion() const{return fChi2CutConversion;} | |
456 | ||
457 | /* | |
458 | * Gets the Chi2 cut value for the mesons. | |
459 | */ | |
460 | Double_t GetChi2CutMeson() const{return fChi2CutMeson;} | |
461 | ||
462 | Double_t GetPositiveTrackLength() const{return fCurrentPositiveESDTrack->GetIntegratedLength();} | |
463 | Double_t GetNegativeTrackLength() const{return fCurrentNegativeESDTrack->GetIntegratedLength();} | |
464 | ||
465 | Double_t GetPositiveNTPCClusters() const{return fCurrentPositiveESDTrack->GetTPCNcls();} | |
466 | Double_t GetNegativeNTPCClusters() const{return fCurrentNegativeESDTrack->GetTPCNcls();} | |
467 | ||
468 | /* | |
469 | * Sets the MaxRCut value. | |
470 | */ | |
471 | void SetMaxRCut(Double_t maxR){fMaxR=maxR;} | |
472 | ||
473 | /* | |
474 | * Sets the EtaCut value. | |
475 | */ | |
476 | void SetEtaCut(Double_t etaCut){fEtaCut=etaCut;} | |
477 | ||
478 | /* | |
479 | * Sets the PtCut value. | |
480 | */ | |
481 | void SetPtCut(Double_t ptCut){fPtCut=ptCut;} | |
482 | ||
483 | ||
484 | /* | |
485 | * Sets the MaxZCut value. | |
486 | */ | |
487 | void SetMaxZCut(Double_t maxZ){fMaxZ=maxZ;} | |
488 | ||
489 | ||
490 | /* | |
491 | * Sets the LineCut values. | |
492 | */ | |
493 | void SetLineCutZRSlope(Double_t LineCutZRSlope){fLineCutZRSlope=LineCutZRSlope;} | |
494 | void SetLineCutZValue(Double_t LineCutZValue){fLineCutZValue=LineCutZValue;} | |
495 | ||
496 | /* | |
497 | * Sets the Chi2Cut value for conversions. | |
498 | */ | |
499 | void SetChi2CutConversion(Double_t chi2){fChi2CutConversion=chi2;} | |
500 | ||
501 | /* | |
502 | * Sets the Chi2Cut for the mesons. | |
503 | */ | |
504 | void SetChi2CutMeson(Double_t chi2){fChi2CutMeson=chi2;} | |
505 | ||
506 | /* | |
507 | * Sets the XVertexCut value. | |
508 | */ | |
509 | void SetXVertexCut(Double_t xVtx){fCurrentXValue=xVtx;} | |
510 | ||
511 | /* | |
512 | * Sets the YVertexCut value. | |
513 | */ | |
514 | void SetYVertexCut(Double_t yVtx){fCurrentYValue=yVtx;} | |
515 | ||
516 | /* | |
517 | * Sets the ZVertexCut value. | |
518 | */ | |
519 | void SetZVertexCut(Double_t zVtx){fCurrentZValue=zVtx;} | |
520 | ||
521 | /* | |
522 | * Sets the PIDProbabilityCut value for track particles. | |
523 | */ | |
524 | void SetPIDProbability(Double_t pidProb){fPIDProbabilityCutPositiveParticle=pidProb; fPIDProbabilityCutNegativeParticle=pidProb;} | |
525 | ||
526 | /* | |
527 | * Sets the PIDProbability cut value for the negative track. | |
528 | */ | |
529 | void SetPIDProbabilityNegativeParticle(Double_t pidProb){fPIDProbabilityCutNegativeParticle=pidProb;} | |
530 | ||
531 | /* | |
532 | * Sets the PIDProbability cut value for the positive track. | |
533 | */ | |
534 | void SetPIDProbabilityPositiveParticle(Double_t pidProb){fPIDProbabilityCutPositiveParticle=pidProb;} | |
9640a3d1 | 535 | |
536 | /* | |
537 | * Sets the PIDnSigmaAboveElectron cut value for the tracks. | |
538 | */ | |
539 | void SetPIDnSigmaAboveElectronLine(Double_t nSigmaAbove){fPIDnSigmaAboveElectronLine=nSigmaAbove;} | |
540 | ||
541 | /* | |
542 | * Sets the PIDnSigmaBelowElectron cut value for the tracks. | |
543 | */ | |
544 | void SetPIDnSigmaBelowElectronLine(Double_t nSigmaBelow){fPIDnSigmaBelowElectronLine=nSigmaBelow;} | |
a0b94e5c | 545 | |
9640a3d1 | 546 | /* |
547 | * Sets the PIDnSigmaAbovePion cut value for the tracks. | |
548 | */ | |
549 | void SetPIDnSigmaAbovePionLine(Double_t nSigmaAbovePion){fPIDnSigmaAbovePionLine=nSigmaAbovePion;} | |
550 | ||
551 | /* | |
552 | * Sets the PIDMinPnSigmaAbovePion cut value for the tracks. | |
553 | */ | |
554 | void SetPIDMinPnSigmaAbovePionLine(Double_t MinPnSigmaAbovePion){fPIDMinPnSigmaAbovePionLine=MinPnSigmaAbovePion;} | |
555 | ||
a0b94e5c | 556 | /* |
557 | * Sets the SigmaMassCut value. | |
558 | */ | |
559 | void SetSigmaMass(Double_t sigmaMass){fNSigmaMass=sigmaMass;} | |
560 | ||
561 | /* | |
562 | * Sets the flag to enable/disable the usage of MC information. | |
563 | */ | |
564 | void SetDoMCTruth(Bool_t doMC){fDoMC = doMC;} | |
61374d97 | 565 | |
566 | /* | |
567 | * Sets the flag to enable/disable the usage of MC information. | |
568 | */ | |
037dc2db | 569 | Bool_t GetDoMCTruth() const {return fDoMC;} |
a0b94e5c | 570 | |
9640a3d1 | 571 | /* |
572 | * Sets the flag to enable/disable the cut dedx N sigma | |
573 | */ | |
574 | ||
575 | void SetDodEdxSigmaCut( Bool_t dodEdxSigmaCut){fDodEdxSigmaCut=dodEdxSigmaCut;} | |
576 | ||
577 | ||
a0b94e5c | 578 | /* |
579 | * Updates the V0 information of the current V0. | |
580 | */ | |
581 | Bool_t UpdateV0Information(); | |
582 | ||
583 | /* | |
584 | * Resets the V0 index. | |
585 | */ | |
586 | void ResetV0IndexNumber(){fCurrentV0IndexNumber=0;} | |
587 | ||
588 | /* | |
589 | * Sets the histograms. | |
590 | */ | |
4a6157dc | 591 | void SetHistograms(AliGammaConversionHistograms * const histograms){fHistograms=histograms;} |
a0b94e5c | 592 | |
593 | /* | |
594 | * Check for primary vertex. | |
595 | */ | |
596 | Bool_t CheckForPrimaryVertex(); | |
597 | ||
598 | /* | |
599 | * Gets a vector of good v0s. | |
600 | */ | |
5e55d806 | 601 | TClonesArray* GetCurrentEventGoodV0s() const{return fCurrentEventGoodV0s;} |
a0b94e5c | 602 | |
603 | /* | |
604 | * Gets the vector of previous events v0s (for bacground analysis) | |
605 | */ | |
5e55d806 | 606 | AliGammaConversionKFVector* GetBGGoodV0s(Int_t event); |
607 | // vector<AliKFParticle> GetPreviousEventGoodV0s() const{return fPreviousEventGoodV0s;} | |
a0b94e5c | 608 | |
609 | void SetUseOwnXYZCalculation(Bool_t flag){fUseOwnXYZCalculation=flag;} | |
610 | ||
611 | Bool_t GetHelixCenter(AliESDtrack* track, Double_t b,Int_t charge, Double_t center[2]); | |
612 | ||
613 | Bool_t GetConvPosXY(AliESDtrack* ptrack,AliESDtrack* ntrack, Double_t b, Double_t convpos[2]); | |
614 | ||
615 | Double_t GetConvPosZ(AliESDtrack* ptrack,AliESDtrack* ntrack, Double_t b); | |
1e7846f4 | 616 | |
617 | void SetDoCF(Bool_t flag){fDoCF = flag;} | |
618 | ||
77880bd8 | 619 | Bool_t CheckV0FinderStatus(Int_t index); |
620 | ||
621 | void SetOnFlyFlag(Bool_t flag){fUseOnFlyV0Finder = flag;} | |
87f6de3e | 622 | |
623 | Int_t GetNBGEvents(){return fBGEventHandler->GetNBGEvents();} | |
77880bd8 | 624 | |
87f6de3e | 625 | void SetCalculateBackground(Bool_t flag){fCalculateBackground=flag;} |
77880bd8 | 626 | |
037dc2db | 627 | AliGammaConversionBGHandler* GetBGHandler() const {return fBGEventHandler;} |
628 | ||
629 | Double_t GetVertexZ(){return fESDEvent->GetPrimaryVertex()->GetZ();} | |
630 | ||
631 | Int_t GetMultiplicity(){return CountESDTracks();} | |
632 | ||
633 | void SetESDtrackCuts(AliESDtrackCuts * const trackCuts){fEsdTrackCuts = trackCuts;} | |
634 | ||
635 | Int_t CountESDTracks(); | |
636 | ||
637 | Int_t GetCurrentV0IndexNumber() const {return fCurrentV0IndexNumber;} | |
638 | ||
639 | Bool_t CheckIfPi0IsMother(Int_t label); | |
640 | ||
a0b94e5c | 641 | private: |
642 | AliStack * fMCStack; // pointer to MonteCarlo particle stack | |
643 | AliMCEventHandler* fMCTruth; // for CF pointer to the MC object | |
644 | AliMCEvent *fMCEvent; // for CF pointer to MC event | |
645 | TChain * fChain; // pointer to the TChain | |
646 | ||
647 | AliESDInputHandler* fESDHandler; //! pointer to esd object | |
648 | AliESDEvent *fESDEvent; //! pointer to esd object | |
649 | ||
650 | ||
651 | // for CF | |
4a6157dc | 652 | AliCFManager *fCFManager; // pointer to the cf manager |
653 | // AliCFContainer *container; | |
a0b94e5c | 654 | |
9640a3d1 | 655 | // for dEdx cut based on nSigma to a particle line |
037dc2db | 656 | AliESDpid * fESDpid; // esd pid |
a0b94e5c | 657 | |
a81d2986 | 658 | AliGammaConversionHistograms *fHistograms; // pointer to histogram handling class |
a0b94e5c | 659 | |
4a6157dc | 660 | Int_t fCurrentV0IndexNumber; // the current v0 index number |
a0b94e5c | 661 | AliESDv0 * fCurrentV0; //! pointer to the current v0 |
662 | AliKFParticle * fCurrentNegativeKFParticle; //! pointer to the negative KF particle | |
663 | AliKFParticle * fCurrentPositiveKFParticle; //! pointer to the positive KF particle | |
664 | AliKFParticle * fCurrentMotherKFCandidate; //! pointer to the positive KF particle | |
665 | ||
666 | AliESDtrack * fCurrentNegativeESDTrack; //! pointer to the negative ESD track | |
667 | AliESDtrack * fCurrentPositiveESDTrack; //! pointer to the positive ESD track | |
668 | ||
669 | TLorentzVector * fNegativeTrackLorentzVector; //! pointer to the negative Track Lorentz Vector | |
670 | TLorentzVector * fPositiveTrackLorentzVector; //! pointer to the positive Track Lorentz Vector | |
671 | TLorentzVector * fMotherCandidateLorentzVector; //! pointer to the mother candidate Track Lorentz Vector | |
672 | ||
673 | Double_t fCurrentXValue; // current x value | |
674 | Double_t fCurrentYValue; // current y value | |
675 | Double_t fCurrentZValue; // current z value | |
676 | ||
677 | Int_t fPositiveTrackPID; // positive track pid | |
678 | Int_t fNegativeTrackPID; // negative track pid | |
679 | ||
680 | TParticle *fNegativeMCParticle; //! | |
681 | TParticle *fPositiveMCParticle; //! | |
682 | TParticle *fMotherMCParticle; //! | |
683 | ||
684 | Double_t fMotherCandidateKFMass; // mass of mother candidate KF particle | |
685 | Double_t fMotherCandidateKFWidth; // width of mother candidate KF particle | |
686 | ||
687 | Bool_t fUseKFParticle; // flag | |
688 | Bool_t fUseESDTrack; // flag | |
689 | Bool_t fDoMC; // flag | |
690 | ||
691 | //cuts | |
692 | Double_t fMaxR; //r cut | |
693 | Double_t fEtaCut; //eta cut | |
694 | Double_t fPtCut; // pt cut | |
695 | Double_t fMaxZ; //z cut | |
696 | Double_t fLineCutZRSlope; //linecut | |
697 | Double_t fLineCutZValue; //linecut | |
698 | Double_t fChi2CutConversion; //chi2cut | |
699 | Double_t fChi2CutMeson; //chi2cut | |
700 | Double_t fPIDProbabilityCutNegativeParticle; //pid cut | |
701 | Double_t fPIDProbabilityCutPositiveParticle; //pid cut | |
9640a3d1 | 702 | Bool_t fDodEdxSigmaCut; // flag to use the dEdxCut based on sigmas |
037dc2db | 703 | Double_t fPIDnSigmaAboveElectronLine; // sigma cut |
704 | Double_t fPIDnSigmaBelowElectronLine; // sigma cut | |
705 | Double_t fPIDnSigmaAbovePionLine; // sigma cut | |
706 | Double_t fPIDMinPnSigmaAbovePionLine; // sigma cut | |
a0b94e5c | 707 | Double_t fXVertexCut; //vertex cut |
708 | Double_t fYVertexCut; //vertex cut | |
709 | Double_t fZVertexCut; // vertexcut | |
710 | ||
711 | Double_t fNSigmaMass; //nsigma cut | |
712 | ||
713 | Bool_t fUseImprovedVertex; //flag | |
714 | ||
715 | Bool_t fUseOwnXYZCalculation; //flag that determines if we use our own calculation of xyz (markus) | |
1e7846f4 | 716 | |
cb90a330 | 717 | Bool_t fDoCF; //flag |
718 | ||
037dc2db | 719 | Bool_t fUseOnFlyV0Finder; //flag |
77880bd8 | 720 | |
cb90a330 | 721 | Bool_t fUpdateV0AlreadyCalled; //flag |
a0b94e5c | 722 | |
5e55d806 | 723 | TClonesArray* fCurrentEventGoodV0s; //vector of good v0s |
724 | // vector<AliKFParticle> fPreviousEventGoodV0s; // vector of good v0s from prevous events | |
725 | ||
037dc2db | 726 | Bool_t fCalculateBackground; //flag |
727 | AliGammaConversionBGHandler *fBGEventHandler; // background handler | |
728 | Bool_t fBGEventInitialized; //flag | |
a0b94e5c | 729 | |
037dc2db | 730 | AliESDtrackCuts *fEsdTrackCuts; // track cuts |
731 | Int_t fNumberOfESDTracks; //track counter | |
732 | ||
733 | ClassDef(AliV0Reader,10) | |
a0b94e5c | 734 | }; |
735 | #endif | |
736 | ||
737 | ||
738 |