[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 "AliGammaConversionBGHandler.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;}

  void SetUseChargedTracksMultiplicityForBG(Bool_t flag){fUseTrackMultiplicityForBG = flag;}		

  void SetMoveParticleAccordingToVertex(Bool_t flag){fMoveParticleAccordingToVertex = flag;}

  void MoveParticleAccordingToVertex(AliKFParticle *particle,AliGammaConversionBGHandler::GammaConversionVertex *vertex);

  void SetApplyChi2Cut(Bool_t flag){fApplyChi2Cut = 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
  Bool_t fUseTrackMultiplicityForBG;
  Bool_t fMoveParticleAccordingToVertex;
  Bool_t fApplyChi2Cut;

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

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