[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
  
  /// Add reconstructed pions to aod
  void AddPionToAOD(AliKFParticle * pionkf, Double_t mass, Int_t daughter1, Int_t daughter2); 
  void AddOmegaToAOD(AliKFParticle * pionkf, Double_t mass, Int_t daughter1, Int_t daughter2); 
		
  // 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 * fAODGamma; //TClonesArray for gammas to put in AOD
  TClonesArray * fAODPi0; //TTClonesArray for Pi0s to put in AOD
  TClonesArray * fAODOmega; //TTClonesArray for omegas to put in AOD
  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
04bf4381	136
	137	/// Add reconstructed pions to aod
	138	void AddPionToAOD(AliKFParticle * pionkf, Double_t mass, Int_t daughter1, Int_t daughter2);
	139	void AddOmegaToAOD(AliKFParticle * pionkf, Double_t mass, Int_t daughter1, Int_t daughter2);
a0b94e5c	140
4a6157dc	141	// for CF
	142	enum{
	143	kStepGenerated = 0,
	144	kStepReconstructable = 1,
ebcfaa7e	145	kStepGetOnFly = 2,
	146	kStepLikeSign = 3,
	147	kStepTPCRefit = 4,
	148	kStepKinks = 5,
	149	kStepdEdx_electronselection = 6,
	150	kStepdEdx_pionrejection = 7,
	151	kStepNContributors = 8,
	152	kStepTPCPID = 9,
	153	kStepR = 10,
	154	kStepLine = 11,
	155	kStepZ = 12,
48682642	156	kStepMinClsTPC = 13,
	157	kStepSinglePt = 14,
	158	kStepNDF = 15,
	159	kStepChi2 = 16,
	160	kStepEta = 17,
	161	kStepPt = 18,
	162	kStepTrueGamma = 19
4a6157dc	163	};
26923b22	164
d7d7e825	165	AliV0Reader* fV0Reader; // The V0 reader object
a0b94e5c	166
d7d7e825	167	AliStack * fStack; // pointer to the MC particle stack
a0b94e5c	168	AliMCEventHandler *fMCTruth; // for CF pointer to MCTruth
4a6157dc	169	AliMCEvent *fGCMCEvent; // for CF pointer to the MC Event
d7d7e825	170	AliESDEvent* fESDEvent; //pointer to the ESDEvent
a0b94e5c	171	TList * fOutputContainer; // Histogram container
	172	AliCFManager *fCFManager; // for CF
	173	// AliCFContainer *container; // for CF
d7d7e825	174
a0b94e5c	175
a0b94e5c	176
d7d7e825	177	AliGammaConversionHistograms *fHistograms; // Pointer to the histogram handling class
b5832f95	178	Bool_t fTriggerCINT1B; //Flag to select trigger CINT1B
d7d7e825	179	Bool_t fDoMCTruth; // Flag to switch on/off MC truth
6c84d371	180	Bool_t fDoNeutralMeson; // flag
6272370b	181	Bool_t fDoOmegaMeson; // flag
6c84d371	182	Bool_t fDoJet; // flag
6c84d371	183	Bool_t fDoChic; // flag
9c1cb6f7	184	Bool_t fRecalculateV0ForGamma;//flag
a0b94e5c	185
6c84d371	186	TClonesArray * fKFReconstructedGammasTClone; //! transient
6272370b	187	TClonesArray * fKFReconstructedPi0sTClone; //! transient
9c1cb6f7	188	TClonesArray * fKFRecalculatedGammasTClone; //! transient
6c84d371	189	TClonesArray * fCurrentEventPosElectronTClone; //! transient
	190	TClonesArray * fCurrentEventNegElectronTClone; //! transient
	191	TClonesArray * fKFReconstructedGammasCutTClone; //! transient
	192	TClonesArray * fPreviousEventTLVNegElectronTClone; //! transient
	193	TClonesArray * fPreviousEventTLVPosElectronTClone; //! transient
a0b94e5c	194
6c84d371	195	// vector<AliKFParticle> fKFReconstructedGammas; // vector containing all reconstructed gammas
d7d7e825	196	vector<Int_t> fElectronv1; // vector containing index of electron 1
d7d7e825	197	vector<Int_t> fElectronv2; // vector containing index of electron 2
a0b94e5c	198
6272370b	199	vector<Int_t> fGammav1; // vector containing index of gamma 1
6272370b	200	vector<Int_t> fGammav2; // vector containing index of gamma 2
9c1cb6f7	201
	202	vector<Int_t> fElectronRecalculatedv1; // vector containing index of electron 1
	203	vector<Int_t> fElectronRecalculatedv2; // vector containing index of electron 2
6272370b	204
9c1cb6f7	205	// AliESDpid * fESDpid; // esd pid
6272370b	206
6272370b	207
d7d7e825	208	///////Chi_c Analysis///////////////////////////
6c84d371	209	// vector<AliESDtrack*> fCurrentEventPosElectron; // comment here
	210	// vector<AliESDtrack*> fCurrentEventNegElectron; // comment here
	211	// vector<AliKFParticle> fKFReconstructedGammasCut; // comment here
	212	// vector<TLorentzVector> fPreviousEventTLVNegElectron; // comment here
	213	// vector<TLorentzVector> fPreviousEventTLVPosElectron; // comment here
d7d7e825	214	//////////////////////////////////////////////////
a0b94e5c	215
d7d7e825	216	//mass defines
	217	Double_t fElectronMass; //electron mass
	218	Double_t fGammaMass; //gamma mass
	219	Double_t fPi0Mass; //pi0mass
	220	Double_t fEtaMass; //eta mass
a0b94e5c	221
d7d7e825	222	// width defines
	223	Double_t fGammaWidth; //gamma width cut
	224	Double_t fPi0Width; // pi0 width cut
	225	Double_t fEtaWidth; // eta width cut
a0b94e5c	226
d7d7e825	227	Double_t fMinOpeningAngleGhostCut; // minimum angle cut
a0b94e5c	228
d7d7e825	229	AliESDtrackCuts* fEsdTrackCuts; // Object containing the parameters of the esd track cuts
a0b94e5c	230
d7d7e825	231	Bool_t fCalculateBackground; //flag to set backgrount calculation on/off
	232	Bool_t fWriteNtuple; // flag to set if writing to ntuple on/off
	233	TNtuple *fGammaNtuple; // Ntuple for gamma values
	234	TNtuple *fNeutralMesonNtuple;// NTuple for mesons
a0b94e5c	235
d7d7e825	236	Int_t fTotalNumberOfAddedNtupleEntries; // number of added ntuple entries
a0b94e5c	237
6c84d371	238	TClonesArray* fChargedParticles; //! transient
6c84d371	239	vector<Int_t> fChargedParticlesId; //! transient
a0b94e5c	240
6c84d371	241	Double_t fGammaPtHighest; //! transient
	242	Double_t fMinPtForGammaJet; //! transient
	243	Double_t fMinIsoConeSize; //! transient
	244	Double_t fMinPtIsoCone; //! transient
	245	Double_t fMinPtGamChargedCorr; //! transient
	246	Double_t fMinPtJetCone; //! transient
	247	Int_t fLeadingChargedIndex; //! transient
1e7846f4	248	Double_t fLowPtMapping; //! transient
	249	Double_t fHighPtMapping; //! transient
	250	Bool_t fDoCF; //! transient
a0b94e5c	251
04bf4381	252	TClonesArray * fAODGamma; //TClonesArray for gammas to put in AOD
	253	TClonesArray * fAODPi0; //TTClonesArray for Pi0s to put in AOD
	254	TClonesArray * fAODOmega; //TTClonesArray for omegas to put in AOD
d7d7e825	255	TString fAODBranchName; // New AOD branch name
d765d400	256	Bool_t fKFForceAOD; //Set the Analysis Manager FillAOD variable to true every event
332f1f44	257	TString fKFDeltaAODFileName; //! File name for delta AOD (if any)
037dc2db	258	Bool_t fDoNeutralMesonV0MCCheck; //flag
	259
	260	vector<Int_t>fKFReconstructedGammasV0Index; // index of the reconstructed v0s
	261
332f1f44	262	ClassDef(AliAnalysisTaskGammaConversion, 9); // Analysis task for gamma conversions
d7d7e825	263	};
a0b94e5c	264
d7d7e825	265	#endif //ALIANALYSISTASKGAMMA_H