[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 AliKFParticle;
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 Exec(Option_t *option);
  virtual void Terminate(Option_t *option);
  virtual void ConnectInputData(Option_t *);
		
  void ProcessMCData();
  void ProcessV0sNoCut();
  void ProcessV0s();
  void ProcessGammasForNeutralMesonAnalysis();
		
  // 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 FillAODWithConversionGammas();
  // end AOD
		
		
  // 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 SetDoMCTruth(Bool_t flag){fDoMCTruth=flag;}
  void SetDoNeutralMeson(Bool_t flag){fDoNeutralMeson=flag;}
  void SetDoJet(Bool_t flag){fDoJet=flag;}
  void SetDoChic(Bool_t flag){fDoChic=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;}
  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();
		
		
  //////////////////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, 
    kStepLikeSign = 2,
    kStepTPCRefit = 3,
    kStepKinks = 4,
    kStepGetOnFly = 5,
    kStepNContributors = 6,
    kStepTPCPID = 7,
    kStepR = 8,
    kStepLine = 9,
    kStepZ = 10,
    kStepNDF = 11,
    kStepChi2 = 12,
    kStepEta = 13,
    kStepPt = 14
  };

  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 fDoMCTruth; // Flag to switch on/off MC truth 
  Bool_t fDoNeutralMeson; // flag
  Bool_t fDoJet; // flag
  Bool_t fDoChic; // flag
		
  TClonesArray * fKFReconstructedGammasTClone; //! 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
		
  ///////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
		
  //  TClonesArray *fAODObjects;
		
  ClassDef(AliAnalysisTaskGammaConversion, 5); // Analysis task for gamma conversions
};

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