[u/mrichter/AliRoot.git] / PWG4 / GammaConv / AliAnalysisTaskGammaConversion.h

#ifndef ALIANALYSISTASKGAMMACONVERSION_H
#define ALIANALYSISTASKGAMMACONVERSION_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

////////////////////////////////////////////////
//--------------------------------------------- 
// Class used to do analysis on conversion pairs
//---------------------------------------------
////////////////////////////////////////////////

#include "AliAnalysisTaskSE.h"
#include <vector>
#include "AliV0Reader.h"
//#include "AliCFManager.h"  // for CF
//#include "AliCFContainer.h"   // for CF

class AliGammaConversionAODObject;
class TNtuple;
class AliGammaConversionHistograms;
class AliESDv0;
class AliV0;
class AliKFParticle;
class AliKFVertex;
class AliESDInputHandler;
class AliESDEvent;
class AliAODEvent;
class AliMCEvent;
class TList;
class AliStack;
class AliESDtrackCuts;
class AliCFManager; // for CF
class AliCFContainer; // for CF

class AliAnalysisTaskGammaConversion : public AliAnalysisTaskSE
{
	
 public:
  AliAnalysisTaskGammaConversion();
  AliAnalysisTaskGammaConversion(const char* name);
  virtual ~AliAnalysisTaskGammaConversion() ;// virtual destructor
		
  // Implementation of interface methods
  virtual void UserCreateOutputObjects();
  virtual void Init();
  virtual void LocalInit() {Init();}
  virtual void UserExec(Option_t *option);
  virtual void Terminate(Option_t *option);
  //virtual void ConnectInputData(Option_t * option);
		
  void ProcessMCData();
  void ProcessV0sNoCut();
  void ProcessV0s();
  void ProcessGammasForNeutralMesonAnalysis();
  void ProcessGammasForOmegaMesonAnalysis();
  void ProcessConvPHOSGammasForNeutralMesonAnalysis();
  void RecalculateV0ForGamma();
  // for CF
  void SetCFManager(AliCFManager * const io) {fCFManager = io;};
  AliCFManager *GetCFManager() const {return fCFManager;}
		
		
  // AOD
  TString GetAODBranchName() const {return  fAODBranchName;}
  void SetAODBranchName(TString name)  {fAODBranchName = name ;}	
  void SetForceAOD(Bool_t forceAOD ) { fKFForceAOD = forceAOD; }
  void FillAODWithConversionGammas();
  // end AOD
		
  static Bool_t IsGoodImpPar(AliESDtrack *const track);
	
  // for GammaJetAnalysis
  void ProcessGammasForGammaJetAnalysis();
  void CreateListOfChargedParticles();
  Double_t GetMinimumDistanceToCharge(Int_t indexHighestPtGamma);
  void CalculateJetCone(Int_t gammaIndex);
  Int_t GetIndexHighestPtGamma();
  void SetESDtrackCuts();
  // end of Gamma Jet
		
  void SetMinPtForGammaJet(Double_t minPtForGammaJet){fMinPtForGammaJet=minPtForGammaJet;}
  void SetMinIsoConeSize(Double_t minIsoConeSize){fMinIsoConeSize=minIsoConeSize;}
  void SetMinPtIsoCone(Double_t minPtIsoCone){fMinPtIsoCone=minPtIsoCone;}
  void SetMinPtGamChargedCorr(Double_t minPtGamChargedCorr){fMinPtGamChargedCorr=minPtGamChargedCorr;}
  void SetMinPtJetCone(Double_t minPtJetCone){fMinPtJetCone=minPtJetCone;}

  void SetLowPtMapping(Double_t lowPtMapping){fLowPtMapping=lowPtMapping;}
  void SetHighPtMapping(Double_t highPtMapping){fHighPtMapping=highPtMapping;}

		
  void SetHistograms(AliGammaConversionHistograms *const histograms){fHistograms=histograms;}
  void SetTriggerCINT1B(Bool_t flag){fTriggerCINT1B=flag;}
  void SetDoMCTruth(Bool_t flag){fDoMCTruth=flag;}
  void SetDoNeutralMeson(Bool_t flag){fDoNeutralMeson=flag;}
  void SetDoOmegaMeson(Bool_t flag){fDoOmegaMeson=flag;}
  void SetDoNeutralMesonV0MCCheck(Bool_t flag){fDoNeutralMesonV0MCCheck=flag;}
  void SetDoJet(Bool_t flag){fDoJet=flag;}
  void SetDoChic(Bool_t flag){fDoChic=flag;}
  void SetRecalculateV0ForGamma(Bool_t flag){fRecalculateV0ForGamma=flag;}		

  void SetElectronMass(Double_t electronMass){fElectronMass = electronMass;}
  void SetGammaMass(Double_t gammaMass){fGammaMass = gammaMass;}
  void SetGammaWidth(Double_t gammaWidth){fGammaWidth = gammaWidth;}
  void SetPi0Mass(Double_t pi0Mass){fPi0Mass = pi0Mass;}
  void SetPi0Width(Double_t pi0Width){fPi0Width = pi0Width;}
  void SetEtaMass(Double_t etaMass){fEtaMass = etaMass;}
  void SetEtaWidth(Double_t etaWidth){fEtaWidth = etaWidth;}
  void SetMinOpeningAngleGhostCut(Double_t ghostCut){fMinOpeningAngleGhostCut = ghostCut;}
  void SetV0Reader(AliV0Reader* const reader){fV0Reader=reader; fV0Reader->SetESDtrackCuts(fEsdTrackCuts);}
  void SetCalculateBackground(Bool_t bg){fCalculateBackground=bg;}
  void CalculateBackground();
  void SetWriteNtuple(Bool_t writeNtuple){fWriteNtuple = writeNtuple;}
  void FillNtuple();
  Double_t GetMCOpeningAngle(TParticle* const daughter0, TParticle* const daughter1) const;
  void CheckV0Efficiency();
  void SetDeltaAODFileName(TString fn) { fKFDeltaAODFileName = fn; };
		
  //////////////////Chi_c Analysis////////////////////////////
  void GetPID(AliESDtrack *track, Stat_t &pid, Stat_t &weight);	
  double GetSigmaToVertex(AliESDtrack* t);
  void ElectronBackground(TString hBg, TClonesArray e);
  void FillAngle(TString histoName,TClonesArray const tlVeNeg, TClonesArray const tlVePos);
  void FillElectronInvMass(TString histoName, TClonesArray const negativeElectron, TClonesArray const positiveElectron);
  void FillGammaElectronInvMass(TString histoMass,TString histoDiff, TClonesArray const fKFGammas, TClonesArray const tlVeNeg,TClonesArray const tlVePos);
  void CleanWithAngleCuts(TClonesArray const negativeElectrons, TClonesArray const positiveElectrons, TClonesArray const gammas);
  TClonesArray GetTLorentzVector(TClonesArray* esdTrack);	
  void ProcessGammaElectronsForChicAnalysis();
  ///////////////////////////////////////////////////////////////

  void SetDoCF(Bool_t flag){fDoCF = flag;}
		
 private:
  AliAnalysisTaskGammaConversion(const AliAnalysisTaskGammaConversion&); // Not implemented
  AliAnalysisTaskGammaConversion& operator=(const AliAnalysisTaskGammaConversion&); // Not implemented
		
  // for CF
  enum{
    kStepGenerated = 0,
    kStepReconstructable = 1, 
    kStepGetOnFly = 2,
    kStepLikeSign = 3,
    kStepTPCRefit = 4,
    kStepKinks = 5,
    kStepdEdx_electronselection = 6,
    kStepdEdx_pionrejection = 7,
    kStepNContributors = 8,
    kStepTPCPID = 9,
    kStepR = 10,
    kStepLine = 11,
    kStepZ = 12,
    kStepMinClsTPC = 13,
    kStepSinglePt = 14,
    kStepNDF = 15,
    kStepChi2 = 16,
    kStepEta = 17,
    kStepPt = 18,
    kStepTrueGamma = 19
  };
  
  AliV0Reader* fV0Reader; // The V0 reader object 
		
  AliStack * fStack; // pointer to the MC particle stack
  AliMCEventHandler *fMCTruth; // for CF   pointer to MCTruth
  AliMCEvent *fGCMCEvent;  // for CF    pointer to the MC Event
  AliESDEvent* fESDEvent; //pointer to the ESDEvent
  TList * fOutputContainer; // Histogram container
  AliCFManager *fCFManager;  // for CF
  //  AliCFContainer *container;   // for CF

		
  AliGammaConversionHistograms *fHistograms; // Pointer to the histogram handling class
  Bool_t fTriggerCINT1B; //Flag to select trigger CINT1B
  Bool_t fDoMCTruth; // Flag to switch on/off MC truth 
  Bool_t fDoNeutralMeson; // flag
  Bool_t fDoOmegaMeson; // flag
  Bool_t fDoJet; // flag
  Bool_t fDoChic; // flag
  Bool_t fRecalculateV0ForGamma;//flag
		
  TClonesArray * fKFReconstructedGammasTClone; //! transient
  TClonesArray * fKFReconstructedPi0sTClone; //! transient
  TClonesArray * fKFRecalculatedGammasTClone; //! transient
  TClonesArray * fCurrentEventPosElectronTClone; //! transient
  TClonesArray * fCurrentEventNegElectronTClone; //! transient
  TClonesArray * fKFReconstructedGammasCutTClone; //! transient
  TClonesArray * fPreviousEventTLVNegElectronTClone; //! transient
  TClonesArray * fPreviousEventTLVPosElectronTClone; //! transient
		
  //  vector<AliKFParticle> fKFReconstructedGammas; // vector containing all reconstructed gammas
  vector<Int_t> fElectronv1; // vector containing index of electron 1
  vector<Int_t> fElectronv2; // vector containing index of electron 2
		
  vector<Int_t> fGammav1; // vector containing index of gamma 1
  vector<Int_t> fGammav2; // vector containing index of gamma 2

  vector<Int_t> fElectronRecalculatedv1; // vector containing index of electron 1
  vector<Int_t> fElectronRecalculatedv2; // vector containing index of electron 2
		
  //  AliESDpid * fESDpid; // esd pid


  ///////Chi_c Analysis///////////////////////////
  //  vector<AliESDtrack*> fCurrentEventPosElectron;       // comment here
  //  vector<AliESDtrack*> fCurrentEventNegElectron;       // comment here
  //  vector<AliKFParticle> fKFReconstructedGammasCut;     // comment here
  //  vector<TLorentzVector> fPreviousEventTLVNegElectron; // comment here
  //  vector<TLorentzVector> fPreviousEventTLVPosElectron; // comment here
  //////////////////////////////////////////////////	
		
  //mass defines
  Double_t fElectronMass; //electron mass
  Double_t fGammaMass;    //gamma mass
  Double_t fPi0Mass;      //pi0mass
  Double_t fEtaMass;      //eta mass
		
  // width defines
  Double_t fGammaWidth; //gamma width cut
  Double_t fPi0Width;   // pi0 width cut
  Double_t fEtaWidth;   // eta width cut
		
  Double_t fMinOpeningAngleGhostCut; // minimum angle cut
		
  AliESDtrackCuts* fEsdTrackCuts;           // Object containing the parameters of the esd track cuts
		
  Bool_t fCalculateBackground; //flag to set backgrount calculation on/off
  Bool_t fWriteNtuple;         // flag to set if writing to ntuple on/off
  TNtuple *fGammaNtuple;       // Ntuple for gamma values
  TNtuple *fNeutralMesonNtuple;// NTuple for mesons
		
  Int_t fTotalNumberOfAddedNtupleEntries; // number of added ntuple entries
		
  TClonesArray* fChargedParticles;  //! transient
  vector<Int_t> fChargedParticlesId;  //! transient
		
  Double_t fGammaPtHighest;  //! transient
  Double_t fMinPtForGammaJet;  //! transient
  Double_t fMinIsoConeSize; //! transient
  Double_t fMinPtIsoCone; //! transient
  Double_t fMinPtGamChargedCorr; //! transient
  Double_t fMinPtJetCone; //! transient
  Int_t    fLeadingChargedIndex; //! transient
  Double_t fLowPtMapping; //! transient
  Double_t fHighPtMapping; //! transient
  Bool_t fDoCF; //! transient
		
  TClonesArray* fAODBranch ;        //! selected particles branch
  TString fAODBranchName; // New AOD branch name
  Bool_t fKFForceAOD;  //Set the Analysis Manager FillAOD variable to true every event
  TString fKFDeltaAODFileName; //! File name for delta AOD (if any)
  Bool_t fDoNeutralMesonV0MCCheck; //flag

  vector<Int_t>fKFReconstructedGammasV0Index; // index of the reconstructed v0s

  ClassDef(AliAnalysisTaskGammaConversion, 9); // Analysis task for gamma conversions
};

#endif //ALIANALYSISTASKGAMMA_H
Commit	Line	Data
d7d7e825	1	#ifndef ALIANALYSISTASKGAMMACONVERSION_H
d7d7e825	2	#define ALIANALYSISTASKGAMMACONVERSION_H
a0b94e5c	3
d7d7e825	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	////////////////////////////////////////////////
	8	//---------------------------------------------
	9	// Class used to do analysis on conversion pairs
	10	//---------------------------------------------
	11	////////////////////////////////////////////////
a0b94e5c	12
d7d7e825	13	#include "AliAnalysisTaskSE.h"
	14	#include <vector>
	15	#include "AliV0Reader.h"
4a6157dc	16	//#include "AliCFManager.h" // for CF
4a6157dc	17	//#include "AliCFContainer.h" // for CF
d7d7e825	18
4a6157dc	19	class AliGammaConversionAODObject;
d7d7e825	20	class TNtuple;
	21	class AliGammaConversionHistograms;
	22	class AliESDv0;
9c1cb6f7	23	class AliV0;
d7d7e825	24	class AliKFParticle;
9c1cb6f7	25	class AliKFVertex;
d7d7e825	26	class AliESDInputHandler;
	27	class AliESDEvent;
	28	class AliAODEvent;
a0b94e5c	29	class AliMCEvent;
d7d7e825	30	class TList;
	31	class AliStack;
	32	class AliESDtrackCuts;
a0b94e5c	33	class AliCFManager; // for CF
a0b94e5c	34	class AliCFContainer; // for CF
d7d7e825	35
	36	class AliAnalysisTaskGammaConversion : public AliAnalysisTaskSE
	37	{
a0b94e5c	38
d7d7e825	39	public:
	40	AliAnalysisTaskGammaConversion();
	41	AliAnalysisTaskGammaConversion(const char* name);
	42	virtual ~AliAnalysisTaskGammaConversion() ;// virtual destructor
a0b94e5c	43
d7d7e825	44	// Implementation of interface methods
	45	virtual void UserCreateOutputObjects();
	46	virtual void Init();
	47	virtual void LocalInit() {Init();}
c00009fb	48	virtual void UserExec(Option_t *option);
d7d7e825	49	virtual void Terminate(Option_t *option);
48682642	50	//virtual void ConnectInputData(Option_t * option);
a0b94e5c	51
d7d7e825	52	void ProcessMCData();
	53	void ProcessV0sNoCut();
	54	void ProcessV0s();
	55	void ProcessGammasForNeutralMesonAnalysis();
6272370b	56	void ProcessGammasForOmegaMesonAnalysis();
6272370b	57	void ProcessConvPHOSGammasForNeutralMesonAnalysis();
9c1cb6f7	58	void RecalculateV0ForGamma();
a0b94e5c	59	// for CF
4a6157dc	60	void SetCFManager(AliCFManager * const io) {fCFManager = io;};
a0b94e5c	61	AliCFManager *GetCFManager() const {return fCFManager;}
	62
	63
d7d7e825	64	// AOD
	65	TString GetAODBranchName() const {return fAODBranchName;}
	66	void SetAODBranchName(TString name) {fAODBranchName = name ;}
d765d400	67	void SetForceAOD(Bool_t forceAOD ) { fKFForceAOD = forceAOD; }
d7d7e825	68	void FillAODWithConversionGammas();
d7d7e825	69	// end AOD
a0b94e5c	70
6272370b	71	static Bool_t IsGoodImpPar(AliESDtrack *const track);
6272370b	72
a0b94e5c	73	// for GammaJetAnalysis
d7d7e825	74	void ProcessGammasForGammaJetAnalysis();
d7d7e825	75	void CreateListOfChargedParticles();
6c84d371	76	Double_t GetMinimumDistanceToCharge(Int_t indexHighestPtGamma);
6c84d371	77	void CalculateJetCone(Int_t gammaIndex);
d7d7e825	78	Int_t GetIndexHighestPtGamma();
	79	void SetESDtrackCuts();
	80	// end of Gamma Jet
a0b94e5c	81
d7d7e825	82	void SetMinPtForGammaJet(Double_t minPtForGammaJet){fMinPtForGammaJet=minPtForGammaJet;}
	83	void SetMinIsoConeSize(Double_t minIsoConeSize){fMinIsoConeSize=minIsoConeSize;}
	84	void SetMinPtIsoCone(Double_t minPtIsoCone){fMinPtIsoCone=minPtIsoCone;}
	85	void SetMinPtGamChargedCorr(Double_t minPtGamChargedCorr){fMinPtGamChargedCorr=minPtGamChargedCorr;}
	86	void SetMinPtJetCone(Double_t minPtJetCone){fMinPtJetCone=minPtJetCone;}
9640a3d1	87
	88	void SetLowPtMapping(Double_t lowPtMapping){fLowPtMapping=lowPtMapping;}
	89	void SetHighPtMapping(Double_t highPtMapping){fHighPtMapping=highPtMapping;}
	90
a0b94e5c	91
d7d7e825	92	void SetHistograms(AliGammaConversionHistograms *const histograms){fHistograms=histograms;}
b5832f95	93	void SetTriggerCINT1B(Bool_t flag){fTriggerCINT1B=flag;}
d7d7e825	94	void SetDoMCTruth(Bool_t flag){fDoMCTruth=flag;}
d7d7e825	95	void SetDoNeutralMeson(Bool_t flag){fDoNeutralMeson=flag;}
6272370b	96	void SetDoOmegaMeson(Bool_t flag){fDoOmegaMeson=flag;}
037dc2db	97	void SetDoNeutralMesonV0MCCheck(Bool_t flag){fDoNeutralMesonV0MCCheck=flag;}
d7d7e825	98	void SetDoJet(Bool_t flag){fDoJet=flag;}
d7d7e825	99	void SetDoChic(Bool_t flag){fDoChic=flag;}
9c1cb6f7	100	void SetRecalculateV0ForGamma(Bool_t flag){fRecalculateV0ForGamma=flag;}
9c1cb6f7	101
d7d7e825	102	void SetElectronMass(Double_t electronMass){fElectronMass = electronMass;}
	103	void SetGammaMass(Double_t gammaMass){fGammaMass = gammaMass;}
	104	void SetGammaWidth(Double_t gammaWidth){fGammaWidth = gammaWidth;}
	105	void SetPi0Mass(Double_t pi0Mass){fPi0Mass = pi0Mass;}
	106	void SetPi0Width(Double_t pi0Width){fPi0Width = pi0Width;}
	107	void SetEtaMass(Double_t etaMass){fEtaMass = etaMass;}
	108	void SetEtaWidth(Double_t etaWidth){fEtaWidth = etaWidth;}
	109	void SetMinOpeningAngleGhostCut(Double_t ghostCut){fMinOpeningAngleGhostCut = ghostCut;}
037dc2db	110	void SetV0Reader(AliV0Reader* const reader){fV0Reader=reader; fV0Reader->SetESDtrackCuts(fEsdTrackCuts);}
d7d7e825	111	void SetCalculateBackground(Bool_t bg){fCalculateBackground=bg;}
	112	void CalculateBackground();
	113	void SetWriteNtuple(Bool_t writeNtuple){fWriteNtuple = writeNtuple;}
	114	void FillNtuple();
	115	Double_t GetMCOpeningAngle(TParticle* const daughter0, TParticle* const daughter1) const;
	116	void CheckV0Efficiency();
332f1f44	117	void SetDeltaAODFileName(TString fn) { fKFDeltaAODFileName = fn; };
a0b94e5c	118
d7d7e825	119	//////////////////Chi_c Analysis////////////////////////////
	120	void GetPID(AliESDtrack *track, Stat_t &pid, Stat_t &weight);
	121	double GetSigmaToVertex(AliESDtrack* t);
6c84d371	122	void ElectronBackground(TString hBg, TClonesArray e);
	123	void FillAngle(TString histoName,TClonesArray const tlVeNeg, TClonesArray const tlVePos);
	124	void FillElectronInvMass(TString histoName, TClonesArray const negativeElectron, TClonesArray const positiveElectron);
	125	void FillGammaElectronInvMass(TString histoMass,TString histoDiff, TClonesArray const fKFGammas, TClonesArray const tlVeNeg,TClonesArray const tlVePos);
	126	void CleanWithAngleCuts(TClonesArray const negativeElectrons, TClonesArray const positiveElectrons, TClonesArray const gammas);
	127	TClonesArray GetTLorentzVector(TClonesArray* esdTrack);
d7d7e825	128	void ProcessGammaElectronsForChicAnalysis();
d7d7e825	129	///////////////////////////////////////////////////////////////
1e7846f4	130
1e7846f4	131	void SetDoCF(Bool_t flag){fDoCF = flag;}
a0b94e5c	132
d7d7e825	133	private:
	134	AliAnalysisTaskGammaConversion(const AliAnalysisTaskGammaConversion&); // Not implemented
	135	AliAnalysisTaskGammaConversion& operator=(const AliAnalysisTaskGammaConversion&); // Not implemented
a0b94e5c	136
4a6157dc	137	// for CF
	138	enum{
	139	kStepGenerated = 0,
	140	kStepReconstructable = 1,
ebcfaa7e	141	kStepGetOnFly = 2,
	142	kStepLikeSign = 3,
	143	kStepTPCRefit = 4,
	144	kStepKinks = 5,
	145	kStepdEdx_electronselection = 6,
	146	kStepdEdx_pionrejection = 7,
	147	kStepNContributors = 8,
	148	kStepTPCPID = 9,
	149	kStepR = 10,
	150	kStepLine = 11,
	151	kStepZ = 12,
48682642	152	kStepMinClsTPC = 13,
	153	kStepSinglePt = 14,
	154	kStepNDF = 15,
	155	kStepChi2 = 16,
	156	kStepEta = 17,
	157	kStepPt = 18,
	158	kStepTrueGamma = 19
4a6157dc	159	};
26923b22	160
d7d7e825	161	AliV0Reader* fV0Reader; // The V0 reader object
a0b94e5c	162
d7d7e825	163	AliStack * fStack; // pointer to the MC particle stack
a0b94e5c	164	AliMCEventHandler *fMCTruth; // for CF pointer to MCTruth
4a6157dc	165	AliMCEvent *fGCMCEvent; // for CF pointer to the MC Event
d7d7e825	166	AliESDEvent* fESDEvent; //pointer to the ESDEvent
a0b94e5c	167	TList * fOutputContainer; // Histogram container
	168	AliCFManager *fCFManager; // for CF
	169	// AliCFContainer *container; // for CF
d7d7e825	170
a0b94e5c	171
a0b94e5c	172
d7d7e825	173	AliGammaConversionHistograms *fHistograms; // Pointer to the histogram handling class
b5832f95	174	Bool_t fTriggerCINT1B; //Flag to select trigger CINT1B
d7d7e825	175	Bool_t fDoMCTruth; // Flag to switch on/off MC truth
6c84d371	176	Bool_t fDoNeutralMeson; // flag
6272370b	177	Bool_t fDoOmegaMeson; // flag
6c84d371	178	Bool_t fDoJet; // flag
6c84d371	179	Bool_t fDoChic; // flag
9c1cb6f7	180	Bool_t fRecalculateV0ForGamma;//flag
a0b94e5c	181
6c84d371	182	TClonesArray * fKFReconstructedGammasTClone; //! transient
6272370b	183	TClonesArray * fKFReconstructedPi0sTClone; //! transient
9c1cb6f7	184	TClonesArray * fKFRecalculatedGammasTClone; //! transient
6c84d371	185	TClonesArray * fCurrentEventPosElectronTClone; //! transient
	186	TClonesArray * fCurrentEventNegElectronTClone; //! transient
	187	TClonesArray * fKFReconstructedGammasCutTClone; //! transient
	188	TClonesArray * fPreviousEventTLVNegElectronTClone; //! transient
	189	TClonesArray * fPreviousEventTLVPosElectronTClone; //! transient
a0b94e5c	190
6c84d371	191	// vector<AliKFParticle> fKFReconstructedGammas; // vector containing all reconstructed gammas
d7d7e825	192	vector<Int_t> fElectronv1; // vector containing index of electron 1
d7d7e825	193	vector<Int_t> fElectronv2; // vector containing index of electron 2
a0b94e5c	194
6272370b	195	vector<Int_t> fGammav1; // vector containing index of gamma 1
6272370b	196	vector<Int_t> fGammav2; // vector containing index of gamma 2
9c1cb6f7	197
	198	vector<Int_t> fElectronRecalculatedv1; // vector containing index of electron 1
	199	vector<Int_t> fElectronRecalculatedv2; // vector containing index of electron 2
6272370b	200
9c1cb6f7	201	// AliESDpid * fESDpid; // esd pid
6272370b	202
6272370b	203
d7d7e825	204	///////Chi_c Analysis///////////////////////////
6c84d371	205	// vector<AliESDtrack*> fCurrentEventPosElectron; // comment here
	206	// vector<AliESDtrack*> fCurrentEventNegElectron; // comment here
	207	// vector<AliKFParticle> fKFReconstructedGammasCut; // comment here
	208	// vector<TLorentzVector> fPreviousEventTLVNegElectron; // comment here
	209	// vector<TLorentzVector> fPreviousEventTLVPosElectron; // comment here
d7d7e825	210	//////////////////////////////////////////////////
a0b94e5c	211
d7d7e825	212	//mass defines
	213	Double_t fElectronMass; //electron mass
	214	Double_t fGammaMass; //gamma mass
	215	Double_t fPi0Mass; //pi0mass
	216	Double_t fEtaMass; //eta mass
a0b94e5c	217
d7d7e825	218	// width defines
	219	Double_t fGammaWidth; //gamma width cut
	220	Double_t fPi0Width; // pi0 width cut
	221	Double_t fEtaWidth; // eta width cut
a0b94e5c	222
d7d7e825	223	Double_t fMinOpeningAngleGhostCut; // minimum angle cut
a0b94e5c	224
d7d7e825	225	AliESDtrackCuts* fEsdTrackCuts; // Object containing the parameters of the esd track cuts
a0b94e5c	226
d7d7e825	227	Bool_t fCalculateBackground; //flag to set backgrount calculation on/off
	228	Bool_t fWriteNtuple; // flag to set if writing to ntuple on/off
	229	TNtuple *fGammaNtuple; // Ntuple for gamma values
	230	TNtuple *fNeutralMesonNtuple;// NTuple for mesons
a0b94e5c	231
d7d7e825	232	Int_t fTotalNumberOfAddedNtupleEntries; // number of added ntuple entries
a0b94e5c	233
6c84d371	234	TClonesArray* fChargedParticles; //! transient
6c84d371	235	vector<Int_t> fChargedParticlesId; //! transient
a0b94e5c	236
6c84d371	237	Double_t fGammaPtHighest; //! transient
	238	Double_t fMinPtForGammaJet; //! transient
	239	Double_t fMinIsoConeSize; //! transient
	240	Double_t fMinPtIsoCone; //! transient
	241	Double_t fMinPtGamChargedCorr; //! transient
	242	Double_t fMinPtJetCone; //! transient
	243	Int_t fLeadingChargedIndex; //! transient
1e7846f4	244	Double_t fLowPtMapping; //! transient
	245	Double_t fHighPtMapping; //! transient
	246	Bool_t fDoCF; //! transient
a0b94e5c	247
d7d7e825	248	TClonesArray* fAODBranch ; //! selected particles branch
d7d7e825	249	TString fAODBranchName; // New AOD branch name
d765d400	250	Bool_t fKFForceAOD; //Set the Analysis Manager FillAOD variable to true every event
332f1f44	251	TString fKFDeltaAODFileName; //! File name for delta AOD (if any)
037dc2db	252	Bool_t fDoNeutralMesonV0MCCheck; //flag
	253
	254	vector<Int_t>fKFReconstructedGammasV0Index; // index of the reconstructed v0s
	255
332f1f44	256	ClassDef(AliAnalysisTaskGammaConversion, 9); // Analysis task for gamma conversions
d7d7e825	257	};
a0b94e5c	258
d7d7e825	259	#endif //ALIANALYSISTASKGAMMA_H