Fixed warnings regarding par file compilation
[u/mrichter/AliRoot.git] / PWG4 / GammaConv / AliV0Reader.h
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"
22 #include "AliGammaConversionBGHandler.h"
23 #include "AliESDpid.h"
24
25 class TClonesArray; 
26 class TFormula;
27 class Riostream;
28 class TChain;
29
30 //--- AliRoot system ---
31
32 class AliStack;
33 class AliMCEvent;       // for CF
34 class AliESDEvent; 
35 class AliMCEventHandler;
36 class AliESDInputHandler;
37 class AliESDVertex;
38 class AliLog;
39 class TChain;
40 class TChain;
41 class AliCFManager;   // for CF
42 class AliCFContainer;  // for CF
43 //class AliESDpid; // for dEdx cut based on nSigma to particle lines 
44 class AliESDtrackCuts; 
45
46 class AliV0Reader : public TObject {
47         
48  public: 
49         
50         
51   // for CF
52   enum{
53     kStepGenerated = 0,
54     kStepReconstructable = 1, 
55     kStepGetOnFly = 2,
56     kStepLikeSign = 3,
57     kStepTPCRefit = 4,
58     kStepKinks = 5,
59     kStepdEdx_electronselection = 6,
60     kStepdEdx_pionrejection = 7,
61     kStepNContributors = 8,
62     kStepTPCPID = 9,
63     kStepR = 10,
64     kStepLine = 11,
65     kStepZ = 12,
66     kStepMinClsTPC = 13,
67     kStepSinglePt= 14,  
68     kStepNDF = 15,
69     kStepChi2 = 16,
70     kStepEta = 17,
71     kStepPt = 18,
72     kStepTrueGamma = 19
73   };
74         
75   AliV0Reader();                                        //constructor
76   AliV0Reader(const AliV0Reader & g);                   //copy constructor
77   AliV0Reader & operator = (const AliV0Reader & g);     //assignment operator
78   //  virtual ~AliV0Reader() {;}                            //virtual destructor
79   virtual ~AliV0Reader();                            //virtual destructor
80   /*
81    *Initialize the reader
82    */
83   void Initialize();
84   void SetInputAndMCEvent(AliVEvent* esd, AliMCEvent* mc) ;
85
86
87   virtual void SetInputEvent(AliVEvent* const input)  {fESDEvent  = dynamic_cast<AliESDEvent*>(input);}
88   virtual void SetMC(AliMCEvent* const mc)            {fMCEvent = mc;}
89
90         
91   // for CF
92   void SetCFManager(AliCFManager * const io){fCFManager = io;};
93   AliCFManager *GetCFManager() const {return fCFManager;}
94         
95         
96         
97         
98   /*
99    * Returns  AliESDEvent
100    */                   
101   AliESDEvent* GetESDEvent() const{return fESDEvent;}   
102         
103   /*
104    *Returns the number of v0s in the event, no cuts applied.
105    */
106   Int_t GetNumberOfV0s() const{return fESDEvent->GetNumberOfV0s();}
107         
108   /*
109    *Returns the number of contributors to the vertex
110    */
111   Int_t GetNumberOfContributorsVtx() const{return fESDEvent->GetPrimaryVertex()->GetNContributors();}
112   
113   /*
114    * Check if there are any more good v0s left in the v0 stack
115    * if so, fCurrent v0 is set to this v0 and can be retrieved
116    * by GetCurrentV0 function.
117    * returns kFALSE if there is no more good v0s in the v0 stack
118    */
119   Bool_t NextV0();
120         
121   /*
122    * Returns the v0 at the given index, no checks are done on the v0. 
123    */
124   AliESDv0* GetV0(Int_t index);
125         
126   /*
127    * Returns the current v0
128    */
129   AliESDv0* GetCurrentV0() const{return fCurrentV0;}
130         
131   /*
132    * Returns the negative ESD track which belongs to fCurrentV0
133    */
134   //  AliESDtrack* GetNegativeESDTrack(){return fESDEvent->GetTrack(fCurrentV0->GetNindex());}
135   AliESDtrack* GetNegativeESDTrack(){return fCurrentNegativeESDTrack;}
136         
137   /*
138    * Returns the positive ESD track which belongs to fCurrentV0
139    */
140   //  AliESDtrack* GetPositiveESDTrack(){return fESDEvent->GetTrack(fCurrentV0->GetPindex());}
141   AliESDtrack* GetPositiveESDTrack(){return fCurrentPositiveESDTrack;}
142         
143   /*
144    * Returns the negative KF particle which belongs to fCurrentV0
145    */
146   AliKFParticle* GetNegativeKFParticle() const{return fCurrentNegativeKFParticle;}
147         
148   /*
149    * Returns the positive KF particle which belongs to fCurrentV0
150    */
151   AliKFParticle* GetPositiveKFParticle() const{return fCurrentPositiveKFParticle;}
152         
153   /*
154    * Returns the KFParticle object of the 2 tracks.
155    */
156   AliKFParticle* GetMotherCandidateKFCombination() const{return fCurrentMotherKFCandidate;}
157         
158   /*
159    * Checks the probablity that the PID of the particle is what we want it to be.
160    */
161   Bool_t CheckPIDProbability(Double_t negProbCut, Double_t posProbCut);
162         
163   /*
164    * Checks if the PID of the two particles are within our cuts.
165    */
166   void GetPIDProbability(Double_t &negPIDProb, Double_t &posPIDProb);
167
168   /*
169    * Checks if the PID of the two particles are within our cuts.
170    */
171   void GetPIDProbabilityMuonPion(Double_t &negPIDProb, Double_t &posPIDProb);
172         
173   /*
174    *Get the negative MC TParticle from the stack 
175    */
176   TParticle * GetNegativeMCParticle() const{return fNegativeMCParticle;}
177         
178   /*
179    *Get the positive MC TParticle from the stack 
180    */
181   TParticle * GetPositiveMCParticle() const{return fPositiveMCParticle;}
182         
183   /*
184    *Get the mother MC TParticle from the stack 
185    */
186   TParticle * GetMotherMCParticle() const{return fMotherMCParticle;}
187         
188   /*
189    * Flag to see if the v0 particles share the same mother
190    */
191   Bool_t HasSameMCMother();
192         
193         
194   /*
195    *Get the PID of the MC mother particle
196    */
197   Int_t GetMotherMCParticlePDGCode() const{if(fMotherMCParticle != NULL){ cout<<"MCParticle exists"<<endl;} return fMotherMCParticle->GetPdgCode();}
198         
199   /*
200    *Get the MC stack 
201    */
202   AliStack* GetMCStack() const{return fMCStack;}
203         
204         
205   /*
206    * Setup  AliMCEventHandler
207    */                   
208   //  AliMCEventHandler* GetMCTruth() const{return fMCTruth;}   // for CF
209         
210         
211   /*
212    *Get the MC stack 
213    */
214   AliMCEvent* GetMCEvent() const{return fMCEvent;}   // for CF
215         
216         
217   /*
218    *Get the magnetic field from the ESD event 
219    */
220   Double_t GetMagneticField() const{return fESDEvent->GetMagneticField();}
221         
222   /*
223    *Get the primary vertex from the esd event
224    */
225   const AliESDVertex *GetPrimaryVertex() const {return fESDEvent->GetPrimaryVertex();}
226         
227   /*
228    * Set the PID of the negative track
229    */
230   void SetNegativeTrackPID(Int_t negTrackPID){fNegativeTrackPID=negTrackPID;}
231         
232   /*
233    * Set the PID of the positive track
234    */
235   void SetPositiveTrackPID(Int_t posTrackPID){fPositiveTrackPID=posTrackPID;}
236         
237   /*
238    * Set the flag to use the kfparticle class. Will also disable the use of esd tracks
239    */
240   void UseKFParticle(){fUseKFParticle = kTRUE; fUseESDTrack = kFALSE;}
241         
242   /*
243    *  Set the flag to use the esd track class. Will also disable the use of kf particles
244    */
245   void UseESDTrack(){fUseESDTrack = kTRUE; fUseKFParticle = kFALSE;}
246         
247   /*
248    *  Set the flag to use improved vertex or not
249    */
250   void SetUseImprovedVertex(Bool_t useImprovedVertex){fUseImprovedVertex=useImprovedVertex;}
251         
252   /*
253    * Return the number in the species array belonging to the negative or positive track pid.
254    */
255   Int_t GetSpeciesIndex(Int_t chargeOfTrack);
256         
257   /*
258    * Return the x coordinate of the v0
259    */
260   Double_t GetX() const{return fCurrentXValue;}
261         
262   /*
263    * Return the y coordinate of the v0
264    */
265   Double_t GetY() const{return fCurrentYValue;}
266         
267   /*
268    * Return the Z coordinate of the v0
269    */
270   Double_t GetZ() const{return fCurrentZValue;}
271         
272   /*
273    * Return the radius of the v0
274    */
275   Double_t GetXYRadius() const{return sqrt((Double_t)(fCurrentXValue*fCurrentXValue + fCurrentYValue*fCurrentYValue));}
276         
277   /*
278    * Get the opening angle between the two tracks
279    */
280   Double_t GetOpeningAngle(){return fNegativeTrackLorentzVector->Angle(fPositiveTrackLorentzVector->Vect());}
281
282   /*
283    * Get the Cos Pointing angle between the two tracks
284    */
285   Double_t GetCosPointingAngle(){return fCurrentV0->GetV0CosineOfPointingAngle();}
286
287   /*
288    * Get the DCA between the two tracks
289    */
290   Double_t GetDcaDaughters(){return fCurrentV0->GetDcaV0Daughters();}
291
292   /*
293    * Get the Normalized DCA between the two tracks
294    */
295   Double_t GetNormDcaDistDaughters(){return fCurrentV0->GetDcaV0Daughters()/fCurrentV0->GetDistSigma();}
296
297   /*
298    * Get the Likelihood for a Conversion
299    */
300   Double_t GetLikelihoodAP(){return fCurrentV0->GetLikelihoodAP(0,0);}
301       
302   /*
303    * Gets the Energy of the negative track.
304    */
305   Double_t GetNegativeTrackEnergy() const{return fCurrentNegativeKFParticle->E();}
306         
307   /*
308    * Gets the Energy of the positive track.
309    */
310   Double_t GetPositiveTrackEnergy() const{return fCurrentPositiveKFParticle->E();}
311         
312   /*
313    * Gets the Energy of the mother candidate.
314    */
315   Double_t GetMotherCandidateEnergy() const{return fCurrentMotherKFCandidate->E();}
316         
317   /*
318    * Gets the Pt of the negative track.
319    */
320   Double_t GetNegativeTrackPt() const{return fNegativeTrackLorentzVector->Pt();}
321         
322   /*
323    * Gets the Pt of the positive track.
324    */
325   Double_t GetPositiveTrackPt() const{return fPositiveTrackLorentzVector->Pt();}
326         
327
328   /*
329    * Gets the Pt of the mother candidate.
330    */
331   Double_t GetMotherCandidatePt() const{return fMotherCandidateLorentzVector->Pt();}
332
333
334   /*
335    * Gets the P of the mother candidate.
336    */
337   Double_t GetMotherCandidateP() const{return fMotherCandidateLorentzVector->P();}
338         
339
340   /*
341    * Gets the Eta of the negative track.
342    */
343   Double_t GetNegativeTrackEta() const{return fNegativeTrackLorentzVector->Eta();}
344   /*
345    * Gets the Eta of the positive track.
346    */
347   Double_t GetPositiveTrackEta() const{return fPositiveTrackLorentzVector->Eta();}
348   /*
349    * Gets the Eta of the mother candidate.
350    */
351   Double_t GetMotherCandidateEta() const{return fMotherCandidateLorentzVector->Eta();}
352         
353   /*
354    * Gets the NDF of the mother candidate.
355    */
356   Double_t GetMotherCandidateNDF() const{return fCurrentMotherKFCandidate->GetNDF();}
357         
358   /*
359    * Gets the Chi2 of the mother candidate.
360    */
361   Double_t GetMotherCandidateChi2() const{return fCurrentMotherKFCandidate->GetChi2();}
362         
363   /*
364    * Gets the Mass of the mother candidate.
365    */
366   Double_t GetMotherCandidateMass() const{return fMotherCandidateKFMass;}
367         
368   /*
369    * Gets the Width of the mother candidate.
370    */
371   Double_t GetMotherCandidateWidth() const{return fMotherCandidateKFWidth;}
372         
373   /*
374    * Gets the Phi of the negative track.
375    */
376   Double_t GetNegativeTrackPhi() const;
377         
378   /*
379    * Gets the Phi of the positive track.
380    */
381   Double_t GetPositiveTrackPhi() const;
382         
383   /*
384    * Gets the Phi of the mother candidate.
385    */
386   Double_t GetMotherCandidatePhi() const;
387         
388   /*
389    * Gets the Rapidity of the mother candidate.
390    */
391   Double_t GetMotherCandidateRapidity() const;
392         
393
394   /*
395    * Gets the P of the negative track.
396    */
397   Double_t GetNegativeTrackP() const{return fNegativeTrackLorentzVector->P();}
398         
399   /*
400    * Gets the P of the positive track.
401    */
402   Double_t GetPositiveTrackP() const{return fPositiveTrackLorentzVector->P();}
403
404   /*
405    * Gets the dE/dx in the TPC of the negative track.
406    */
407   Double_t GetNegativeTrackTPCdEdx() const{return fCurrentNegativeESDTrack->GetTPCsignal();}
408         
409   /*
410    * Gets the dE/dx in the TPC of the positive track.
411    */
412   Double_t GetPositiveTrackTPCdEdx() const{return fCurrentPositiveESDTrack->GetTPCsignal();}
413
414   /*
415    * Gets the Number of the TPC clusters of the negative track.
416    */
417   Int_t GetNegativeTracknTPCClusters() const{return fCurrentNegativeESDTrack->GetNcls(1);}
418
419   /*
420    * Gets the Number of the TPC clusters of the positive track.
421    */
422   Int_t GetPositiveTracknTPCClusters() const{return fCurrentPositiveESDTrack->GetNcls(1);}
423         
424   /*
425    * Gets the Number of the ITS clusters of the negative track.
426    */
427   Int_t GetNegativeTracknITSClusters() const{return fCurrentNegativeESDTrack->GetNcls(0);}
428
429   /*
430    * Gets the Number of the ITS clusters of the positive track.
431    */
432   Int_t GetPositiveTracknITSClusters() const{return fCurrentPositiveESDTrack->GetNcls(0);}
433         
434   /*
435    * Update data which need to be updated every event.
436    */
437   void UpdateEventByEventData();
438
439   /*
440    * Gets the MaxRCut value.
441    */
442   Double_t GetMaxVertexZ() const{return fMaxVertexZ;}
443         
444   /*
445    * Gets the MaxRCut value.
446    */
447   Double_t GetMaxRCut() const{return fMaxR;}
448         
449   /*
450    * Gets the Eta cut value.
451    */
452   Double_t GetEtaCut() const{return fEtaCut;}
453         
454   /*
455    * Gets the Pt cut value.
456    */
457   Double_t GetPtCut() const{return fPtCut;}
458         
459         
460   /*
461    * Gets the MaxZCut value.
462    */
463   Double_t GetMaxZCut() const{return fMaxZ;}
464         
465         
466   /*
467    * Gets the MinClsTPC value.
468    */
469   Double_t GetMinClsTPCCut() const{return fMinClsTPC;}
470         
471
472   /*
473    * Gets the line cut values.
474    */
475   Double_t GetLineCutZRSlope() const{return fLineCutZRSlope;}
476   Double_t GetLineCutZValue() const{return fLineCutZValue;}
477         
478   /*
479    * Gets the Chi2 cut value for the conversions.
480    */
481   Double_t GetChi2CutConversion() const{return fChi2CutConversion;}
482         
483   /*
484    * Gets the Chi2 cut value for the mesons.
485    */
486   Double_t GetChi2CutMeson() const{return fChi2CutMeson;}
487         
488   /*
489    * Gets the alpha cut value for the mesons.
490    */
491   Double_t GetAlphaCutMeson() const{return fAlphaCutMeson;}
492
493
494   Double_t GetPositiveTrackLength() const{return fCurrentPositiveESDTrack->GetIntegratedLength();}
495   Double_t GetNegativeTrackLength() const{return fCurrentNegativeESDTrack->GetIntegratedLength();}
496         
497   Double_t GetPositiveNTPCClusters() const{return fCurrentPositiveESDTrack->GetTPCNcls();}
498   Double_t GetNegativeNTPCClusters() const{return fCurrentNegativeESDTrack->GetTPCNcls();}
499         
500   /*
501    * Sets the MaxVertexZ value.
502    */
503   void SetMaxVertexZ(Double_t maxVertexZ){fMaxVertexZ=maxVertexZ;}
504
505   /*
506    * Sets the MaxRCut value.
507    */
508   void SetMaxRCut(Double_t maxR){fMaxR=maxR;}
509         
510   /*
511    * Sets the EtaCut value.
512    */
513   void SetEtaCut(Double_t etaCut){fEtaCut=etaCut;}
514         
515   /*
516    * Sets the PtCut value.
517    */
518   void SetPtCut(Double_t ptCut){fPtCut=ptCut;}
519         
520   /*
521    * Sets the PtCut value.
522    */
523   void SetSinglePtCut(Double_t singleptCut){fSinglePtCut=singleptCut;}
524         
525     
526   /*
527    * Sets the MaxZCut value.
528    */
529   void SetMaxZCut(Double_t maxZ){fMaxZ=maxZ;}
530         
531  /*
532    * Sets the MinClsTPC value.
533    */
534   void SetMinClsTPCCut(Double_t minClsTPC){fMinClsTPC=minClsTPC;}
535         
536   /*
537    * Sets the LineCut values.
538    */
539   void SetLineCutZRSlope(Double_t LineCutZRSlope){fLineCutZRSlope=LineCutZRSlope;}
540   void SetLineCutZValue(Double_t LineCutZValue){fLineCutZValue=LineCutZValue;}
541         
542   /*
543    * Sets the Chi2Cut value for conversions.
544    */
545   void SetChi2CutConversion(Double_t chi2){fChi2CutConversion=chi2;}
546         
547   /*
548    * Sets the Chi2Cut for the mesons.
549    */
550   void SetChi2CutMeson(Double_t chi2){fChi2CutMeson=chi2;}
551         
552   /*
553    * Sets the AlphaCut for the mesons.
554    */
555   void SetAlphaCutMeson(Double_t alpha){fAlphaCutMeson=alpha;}
556         
557
558   /*
559    * Sets the XVertexCut value.
560    */
561   void SetXVertexCut(Double_t xVtx){fCurrentXValue=xVtx;}
562         
563   /*
564    * Sets the YVertexCut value.
565    */
566   void SetYVertexCut(Double_t yVtx){fCurrentYValue=yVtx;}
567         
568   /*
569    * Sets the ZVertexCut value.
570    */
571   void SetZVertexCut(Double_t zVtx){fCurrentZValue=zVtx;}
572         
573   /*
574    * Sets the PIDProbabilityCut value for track particles.
575    */
576   void SetPIDProbability(Double_t pidProb){fPIDProbabilityCutPositiveParticle=pidProb; fPIDProbabilityCutNegativeParticle=pidProb;}
577         
578   /*
579    * Sets the PIDProbability cut value for the negative track.
580    */
581   void SetPIDProbabilityNegativeParticle(Double_t pidProb){fPIDProbabilityCutNegativeParticle=pidProb;}
582         
583   /*
584    * Sets the PIDProbability cut value for the positive track.
585    */
586   void SetPIDProbabilityPositiveParticle(Double_t pidProb){fPIDProbabilityCutPositiveParticle=pidProb;}
587
588   /*
589    * Sets the PIDnSigmaAboveElectron cut value for the tracks.
590    */
591   void SetPIDnSigmaAboveElectronLine(Double_t nSigmaAbove){fPIDnSigmaAboveElectronLine=nSigmaAbove;}
592         
593   /*
594    * Sets the PIDnSigmaBelowElectron cut value for the tracks.
595    */
596   void SetPIDnSigmaBelowElectronLine(Double_t nSigmaBelow){fPIDnSigmaBelowElectronLine=nSigmaBelow;}
597         
598   /*
599    * Sets the PIDnSigmaAbovePion cut value for the tracks.
600    */
601   void SetPIDnSigmaAbovePionLine(Double_t nSigmaAbovePion){fPIDnSigmaAbovePionLine=nSigmaAbovePion;}
602
603   /*
604    * Sets the PIDMinPnSigmaAbovePion cut value for the tracks.
605    */
606   void SetPIDMinPnSigmaAbovePionLine(Double_t MinPnSigmaAbovePion){fPIDMinPnSigmaAbovePionLine=MinPnSigmaAbovePion;}
607
608  /*
609    * Sets the PIDMinPnSigmaAbovePion cut value for the tracks.
610    */
611   void SetPIDMaxPnSigmaAbovePionLine(Double_t MaxPnSigmaAbovePion){fPIDMaxPnSigmaAbovePionLine=MaxPnSigmaAbovePion;}
612
613   /*
614    * Sets the SigmaMassCut value.
615    */
616   void SetSigmaMass(Double_t sigmaMass){fNSigmaMass=sigmaMass;}
617         
618   /*
619    * Sets the flag to enable/disable the usage of MC information. 
620    */
621   void SetDoMCTruth(Bool_t doMC){fDoMC = doMC;}
622
623   /*
624    * Sets the flag to enable/disable the usage of MC information. 
625    */
626   Bool_t GetDoMCTruth() const {return fDoMC;}
627         
628   /*
629    * Sets the flag to enable/disable the cut dedx N sigma 
630    */
631
632   void SetDodEdxSigmaCut( Bool_t dodEdxSigmaCut){fDodEdxSigmaCut=dodEdxSigmaCut;}
633
634   /*
635    * Sets the flag to enable/disable the cut dedx N sigma for Kaon Rejection at low p 
636    */
637   void SetDoKaonRejectionLowP( Bool_t doKaonRejectionLowP){fDoKaonRejectionLowP=doKaonRejectionLowP;}
638   /*
639    * Sets the flag to enable/disable the cut dedx N sigma for Proton Rejection at low p 
640    */
641   void SetDoProtonRejectionLowP( Bool_t doProtonRejectionLowP){fDoProtonRejectionLowP=doProtonRejectionLowP;}
642
643   /*
644    * Sets the flag to enable/disable the cut dedx N sigma for Pion Rejection at low p 
645    */
646   void SetDoPionRejectionLowP( Bool_t doPionRejectionLowP){fDoPionRejectionLowP=doPionRejectionLowP;}
647
648   /*
649    * Sets the PIDMinPnSigmaAroundKaon cut value for the tracks.
650    */
651   void SetPIDnSigmaAtLowPAroundKaonLine(Double_t nSigmaAtLowPAroundKaon){fPIDnSigmaAtLowPAroundKaonLine =nSigmaAtLowPAroundKaon;}
652
653   /*
654    * Sets the PIDMinPnSigmaAroundProton cut value for the tracks.
655    */
656   void SetPIDnSigmaAtLowPAroundProtonLine(Double_t nSigmaAtLowPAroundProton){fPIDnSigmaAtLowPAroundProtonLine =nSigmaAtLowPAroundProton;}
657
658   /*
659    * Sets the PIDMinPnSigmaAroundPion cut value for the tracks.
660    */
661   void SetPIDnSigmaAtLowPAroundPionLine(Double_t nSigmaAtLowPAroundPion){fPIDnSigmaAtLowPAroundPionLine =nSigmaAtLowPAroundPion;}
662
663   /*
664    * Sets the PIDMinPnSigmaAbovePion cut value for the tracks.
665    */
666   void SetPIDMinPKaonRejectionLowP(Double_t PIDMinPKaonRejectionLowP ){fPIDMinPKaonRejectionLowP=PIDMinPKaonRejectionLowP;}
667
668   /*
669    * Sets the PIDMinPnSigmaAbovePion cut value for the tracks.
670    */
671   void SetPIDMinPProtonRejectionLowP(Double_t PIDMinPProtonRejectionLowP ){fPIDMinPProtonRejectionLowP=PIDMinPProtonRejectionLowP;}
672   /*
673    * Sets the PIDMinPnSigmaAbovePion cut value for the tracks.
674    */
675   void SetPIDMinPPionRejectionLowP(Double_t PIDMinPPionRejectionLowP ){fPIDMinPPionRejectionLowP=PIDMinPPionRejectionLowP;}
676
677   /*
678    *Set if we want to use Gamma Selection based on Qt from Armenteros
679    */
680   void SetDoQtGammaSelection(Bool_t doQtGammaSelection){fDoQtGammaSelection=doQtGammaSelection;}
681   /*
682    * Sets the MaxQtCut value.
683    */
684   void SetQtMax(Double_t qtMax){fQtMax=qtMax;}
685
686   /*
687    * Updates the V0 information of the current V0.
688    */
689   Bool_t UpdateV0Information();
690         
691   /*
692    * Resets the V0 index.
693    */
694   void ResetV0IndexNumber(){fCurrentV0IndexNumber=0;}
695         
696   /*
697    * Sets the histograms.
698    */
699   void SetHistograms(AliGammaConversionHistograms * const histograms){fHistograms=histograms;}
700         
701   /*
702    * Check for primary vertex.
703    */
704   Bool_t CheckForPrimaryVertex();
705         
706   /*
707    * Check for primary vertex Z.
708    */
709   Bool_t CheckForPrimaryVertexZ();
710
711   /*
712    * Gets a vector of good v0s.
713    */
714   TClonesArray* GetCurrentEventGoodV0s() const{return fCurrentEventGoodV0s;}
715         
716   /*
717    * Gets the vector of previous events v0s (for bacground analysis)
718    */
719   AliGammaConversionKFVector* GetBGGoodV0s(Int_t event);
720   //  vector<AliKFParticle> GetPreviousEventGoodV0s() const{return fPreviousEventGoodV0s;}
721
722   void SetUseOwnXYZCalculation(Bool_t flag){fUseOwnXYZCalculation=flag;}
723
724   Bool_t GetHelixCenter(AliESDtrack* track, Double_t b,Int_t charge, Double_t center[2]);
725         
726   Bool_t GetConvPosXY(AliESDtrack* ptrack,AliESDtrack* ntrack, Double_t b, Double_t convpos[2]);
727         
728   Double_t GetConvPosZ(AliESDtrack* ptrack,AliESDtrack* ntrack, Double_t b);
729
730   Bool_t GetArmenterosQtAlfa(AliKFParticle * posKFparticle,AliKFParticle * negKFparticle,AliKFParticle * gamKFparticle,Double_t armenterosQtAlfa[2]);
731
732   void SetDoCF(Bool_t flag){fDoCF = flag;}
733
734   Bool_t CheckV0FinderStatus(Int_t index);
735
736   void SetOnFlyFlag(Bool_t flag){fUseOnFlyV0Finder = flag;}
737   
738   Int_t GetNBGEvents(){return fBGEventHandler->GetNBGEvents();}
739
740   void SetCalculateBackground(Bool_t flag){fCalculateBackground=flag;}
741
742   AliGammaConversionBGHandler* GetBGHandler() const {return fBGEventHandler;}
743
744   Double_t GetVertexZ(){return fESDEvent->GetPrimaryVertex()->GetZ();}
745
746   Int_t GetMultiplicity(){return CountESDTracks();}
747
748   void SetESDtrackCuts(AliESDtrackCuts * const trackCuts){fEsdTrackCuts = trackCuts;}
749
750   void SetNEventsForBG(Int_t nev){nEventsForBGCalculation = nev;}
751
752   Int_t CountESDTracks();
753
754   Int_t GetCurrentV0IndexNumber() const {return fCurrentV0IndexNumber;}
755
756   Bool_t CheckIfPi0IsMother(Int_t label);
757   Bool_t CheckIfEtaIsMother(Int_t label);
758
759   static void InitESDpid(Int_t type=0);
760   static void SetESDpid(AliESDpid * const pid) {fgESDpid=pid;}
761   static AliESDpid* GetESDpid() {return fgESDpid;}
762  
763
764
765  private:
766   AliStack * fMCStack;           // pointer to MonteCarlo particle stack 
767   //  AliMCEventHandler* fMCTruth;   // for CF    pointer to the MC object
768   AliMCEvent *fMCEvent;                 //  for CF      pointer to MC event
769   TChain * fChain;               // pointer to the TChain
770         
771   //  AliESDInputHandler* fESDHandler;      //! pointer to esd object
772   AliESDEvent *fESDEvent;               //! pointer to esd object
773         
774         
775   // for CF
776   AliCFManager *fCFManager; // pointer to the cf manager
777   //  AliCFContainer *container;
778         
779   // for dEdx cut based on nSigma to a particle line
780   //AliESDpid * fESDpid; // esd pid
781         
782   AliGammaConversionHistograms *fHistograms; // pointer to histogram handling class
783         
784   Int_t fCurrentV0IndexNumber;  // the current v0 index number
785   AliESDv0 * fCurrentV0;                //! pointer to the current v0
786   AliKFParticle * fCurrentNegativeKFParticle;  //! pointer to the negative KF particle
787   AliKFParticle * fCurrentPositiveKFParticle;  //! pointer to the positive KF particle
788   AliKFParticle * fCurrentMotherKFCandidate;   //! pointer to the positive KF particle
789         
790   AliESDtrack * fCurrentNegativeESDTrack;      //! pointer to the negative ESD track
791   AliESDtrack * fCurrentPositiveESDTrack;      //! pointer to the positive ESD track
792         
793   TLorentzVector * fNegativeTrackLorentzVector; //! pointer to the negative Track Lorentz Vector
794   TLorentzVector * fPositiveTrackLorentzVector; //! pointer to the positive Track Lorentz Vector
795   TLorentzVector * fMotherCandidateLorentzVector;   //! pointer to the mother candidate Track Lorentz Vector
796         
797   Double_t fCurrentXValue;   // current x value
798   Double_t fCurrentYValue;   // current y value
799   Double_t fCurrentZValue;   // current z value
800         
801   Int_t fPositiveTrackPID;   // positive track pid
802   Int_t fNegativeTrackPID;   // negative track pid
803         
804   TParticle *fNegativeMCParticle;      //!
805   TParticle *fPositiveMCParticle;      //!
806   TParticle *fMotherMCParticle;        //!
807         
808   Double_t fMotherCandidateKFMass;   // mass of mother candidate KF particle
809   Double_t fMotherCandidateKFWidth;  // width of mother candidate KF particle
810         
811   Bool_t fUseKFParticle;   // flag 
812   Bool_t fUseESDTrack;     // flag 
813   Bool_t fDoMC;            // flag 
814
815   //Event Cuts
816   Double_t fMaxVertexZ;
817   //cuts
818   Double_t fMaxR; //r cut
819   Double_t fEtaCut; //eta cut
820   Double_t fPtCut; // pt cut
821   Double_t fSinglePtCut; // pt cut for electron/positron
822   Double_t fMaxZ; //z cut
823   Double_t fMinClsTPC;
824   Double_t fLineCutZRSlope; //linecut
825   Double_t fLineCutZValue; //linecut
826   Double_t fChi2CutConversion; //chi2cut
827   Double_t fChi2CutMeson;  //chi2cut
828   Double_t fAlphaCutMeson;  //alphacut
829   Double_t fPIDProbabilityCutNegativeParticle; //pid cut
830   Double_t fPIDProbabilityCutPositiveParticle; //pid cut
831   Bool_t   fDodEdxSigmaCut; // flag to use the dEdxCut based on sigmas
832   Double_t fPIDnSigmaAboveElectronLine; // sigma cut
833   Double_t fPIDnSigmaBelowElectronLine; // sigma cut
834   Double_t fPIDnSigmaAbovePionLine;     // sigma cut
835   Double_t fPIDMinPnSigmaAbovePionLine; // sigma cut
836   Double_t fPIDMaxPnSigmaAbovePionLine; // sigma cut
837   Double_t fDoKaonRejectionLowP;   // Kaon rejection at low p
838   Double_t fDoProtonRejectionLowP; // Proton rejection at low p
839   Double_t fDoPionRejectionLowP;   // Pion rejection at low p
840   Double_t fPIDnSigmaAtLowPAroundKaonLine; // sigma cut
841   Double_t fPIDnSigmaAtLowPAroundProtonLine; // sigma cut
842   Double_t fPIDnSigmaAtLowPAroundPionLine; // sigma cut
843   Double_t fPIDMinPKaonRejectionLowP; // Momentum limit to apply kaon rejection
844   Double_t fPIDMinPProtonRejectionLowP; // Momentum limit to apply proton rejection
845   Double_t fPIDMinPPionRejectionLowP; // Momentum limit to apply proton rejection
846   Bool_t   fDoQtGammaSelection; // Select gammas using qtMax
847   Double_t fQtMax; // Maximum Qt from Armenteros to select Gammas
848   Double_t fXVertexCut; //vertex cut
849   Double_t fYVertexCut; //vertex cut
850   Double_t fZVertexCut; // vertexcut
851         
852   Double_t fNSigmaMass; //nsigma cut
853         
854   Bool_t fUseImprovedVertex; //flag
855
856   Bool_t fUseOwnXYZCalculation; //flag that determines if we use our own calculation of xyz (markus)
857
858   Bool_t fDoCF; //flag
859
860   Bool_t fUseOnFlyV0Finder; //flag
861
862   Bool_t fUpdateV0AlreadyCalled; //flag
863         
864   TClonesArray* fCurrentEventGoodV0s; //vector of good v0s
865   //  vector<AliKFParticle> fPreviousEventGoodV0s; // vector of good v0s from prevous events
866
867   Bool_t fCalculateBackground; //flag
868   AliGammaConversionBGHandler *fBGEventHandler; // background handler
869   Bool_t fBGEventInitialized; //flag
870         
871   AliESDtrackCuts *fEsdTrackCuts; // track cuts
872   Int_t fNumberOfESDTracks; //track counter
873
874   static AliESDpid* fgESDpid;                 // ESD pid object
875
876   Int_t nEventsForBGCalculation;
877
878   ClassDef(AliV0Reader,12)
879 };
880
881 inline void AliV0Reader::InitESDpid(Int_t type)
882 {
883   //
884   // initialize PID parameters
885   // type=0 is simulation
886   // type=1 is data
887
888   if (!fgESDpid) fgESDpid=new AliESDpid;
889   Double_t alephParameters[5];
890   // simulation
891   alephParameters[0] = 2.15898e+00/50.;
892   alephParameters[1] = 1.75295e+01;
893   alephParameters[2] = 3.40030e-09;
894   alephParameters[3] = 1.96178e+00;
895   alephParameters[4] = 3.91720e+00;
896   fgESDpid->GetTOFResponse().SetTimeResolution(80.);
897
898   // data
899   if (type==1){
900     alephParameters[0] = 0.0283086;
901     alephParameters[1] = 2.63394e+01;
902     alephParameters[2] = 5.04114e-11;
903     alephParameters[3] = 2.12543e+00;
904     alephParameters[4] = 4.88663e+00;
905     fgESDpid->GetTOFResponse().SetTimeResolution(130.);
906     fgESDpid->GetTPCResponse().SetMip(47.9);
907   }
908
909   fgESDpid->GetTPCResponse().SetBetheBlochParameters(
910     alephParameters[0],alephParameters[1],alephParameters[2],
911     alephParameters[3],alephParameters[4]);
912
913   fgESDpid->GetTPCResponse().SetSigma(3.79301e-03, 2.21280e+04);
914
915 }
916
917 #endif
918
919
920
921
922