[u/mrichter/AliRoot.git] / PWGCF / Correlations / DPhi / AliAnalysisTaskPhiCorrelations.h

#ifndef AliAnalysisTaskPhiCorrelations_H
#define AliAnalysisTaskPhiCorrelations_H

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

////////////////////////////////////////////////////////////////////////
//
// Analysis class for Underlying Event studies w.r.t. leading track
//
// Look for correlations on the tranverse regions w.r.t
// the leading track in the event
//
// This class needs input AODs.
// The output is a list of analysis-specific containers.
//
// The AOD can be either connected to the InputEventHandler  
// for a chain of AOD files 
// or 
// to the OutputEventHandler
// for a chain of ESD files,
// in this case the class should be in the train after the jet-finder
//
//    Authors:
//    Jan Fiete Grosse-Oetringhaus
// 
////////////////////////////////////////////////////////////////////////

#include "AliAnalysisTask.h"
#include "AliUEHist.h"
#include "TString.h"
#include "AliVParticle.h"
#include "AliLog.h"

class AliAODEvent;
class AliAnalyseLeadingTrackUE;
class AliInputEventHandler;
class AliMCEvent;
class AliMCEventHandler;
class AliUEHistograms;
class AliVParticle;
class TH1D;
class TObjArray;
class AliEventPoolManager;
class AliESDEvent;

class  AliAnalysisTaskPhiCorrelations : public AliAnalysisTask
  {
  public:
    AliAnalysisTaskPhiCorrelations(const char* name="AliAnalysisTaskPhiCorrelations");
    virtual           ~AliAnalysisTaskPhiCorrelations();
       
      
    // Implementation of interace methods
    virtual     void   ConnectInputData(Option_t *);
    virtual     void   CreateOutputObjects();
    virtual     void   Exec(Option_t *option);

    // Setters/Getters
    // general configuration
    virtual     void    SetDebugLevel( Int_t level )  { fDebug = level; }
    virtual     void    SetMode(Int_t mode)           { fMode  = mode;  }
    virtual     void    SetReduceMemoryFootprint(Bool_t flag) { fReduceMemoryFootprint = flag; }
    virtual	void	SetEventMixing(Bool_t flag) { fFillMixed = flag; }
    virtual	void    SetMixingTracks(Int_t tracks) { fMixingTracks = tracks; }
    virtual	void	SetCompareCentralities(Bool_t flag) { fCompareCentralities = flag; }
    virtual	void	SetTwoTrackEfficiencyStudy(Bool_t flag) { fTwoTrackEfficiencyStudy = flag; }
    virtual	void	SetUseVtxAxis(Bool_t flag) { fUseVtxAxis = flag; }
    
    // histogram settings
    void SetTrackingEfficiency( const TH1D* hist) { fkTrackingEfficiency = hist; }

    // for event QA
    void   SetTracksInVertex( Int_t val ){ fnTracksVertex = val; }
    void   SetZVertex( Double_t val )    { fZVertex = val; }
    
    // track cuts
    void   SetTrackEtaCut( Double_t val )    { fTrackEtaCut = val; }
    void   SetPtMin(Double_t val)            { fPtMin = val; }
    void   SetFilterBit( UInt_t val )        { fFilterBit = val;  }
    
    void   SetEventSelectionBit( UInt_t val )        { fSelectBit = val;  }
    void   SetUseChargeHadrons( Bool_t val ) { fUseChargeHadrons = val; }
    void   SetSelectCharge(Int_t selectCharge) { fSelectCharge = selectCharge; }
    void   SetTriggerRestrictEta(Float_t eta) { fTriggerRestrictEta = eta; }
    void   SetCentralityMethod(const char* method) { fCentralityMethod = method; }
    void   SetFillpT(Bool_t flag) { fFillpT = flag; }

    
  private:
    AliAnalysisTaskPhiCorrelations(const  AliAnalysisTaskPhiCorrelations &det);
    AliAnalysisTaskPhiCorrelations&   operator=(const  AliAnalysisTaskPhiCorrelations &det);
    void            AddSettingsTree();                                  // add list of settings to output list
    // Analysis methods
    void            AnalyseCorrectionMode();                            // main algorithm to get correction maps
    void            AnalyseDataMode();                                  // main algorithm to get raw distributions
    void            Initialize(); 			                // initialize some common pointer


    // General configuration
    Int_t               fDebug;           //  Debug flag
    Int_t 	        fMode;            //  fMode = 0: data-like analysis 
    				          //  fMode = 1: corrections analysis	
    Bool_t              fReduceMemoryFootprint; // reduce memory consumption by writing less debug histograms
    Bool_t		fFillMixed;		// enable event mixing (default: ON)
    Int_t  		fMixingTracks;		// size of track buffer for event mixing
    Bool_t		fCompareCentralities;	// use the z vtx axis for a centrality comparison
    Bool_t		fTwoTrackEfficiencyStudy; // two-track efficiency study on
    Bool_t		fUseVtxAxis;              // use z vtx as axis (needs 7 times more memory!)
    
    // Pointers to external UE classes
    AliAnalyseLeadingTrackUE*     fAnalyseUE;      //! points to class containing common analysis algorithms
    AliUEHistograms*  fHistos;       //! points to class to handle histograms/containers  
    AliUEHistograms*  fHistosMixed;       //! points to class to handle mixed histograms/containers  
    
    const TH1D* fkTrackingEfficiency;       // used for study of bias by tracking 

    // Handlers and events
    AliAODEvent*             fAOD;             //! AOD Event 
    AliESDEvent*             fESD;             //! ESD Event 
    TClonesArray*            fArrayMC;         //! Array of MC particles 
    AliInputEventHandler*    fInputHandler;    //! Generic InputEventHandler 
    AliMCEvent*              fMcEvent;         //! MC event
    AliMCEventHandler*       fMcHandler;       //! MCEventHandler 
    AliEventPoolManager*     fPoolMgr;         //! event pool manager
    
    // Histogram settings
    TList*              fListOfHistos;    //  Output list of containers 
    
    // Event QA cuts
    Int_t          	fnTracksVertex;        // QA tracks pointing to principal vertex
    Double_t       	fZVertex;              // Position of Vertex in Z direction
    TString             fCentralityMethod;     // Method to determine centrality
    
    // Track cuts
    Double_t      	fTrackEtaCut;          // Eta cut on particles
    Double_t            fPtMin;                // Min pT to start correlations
    UInt_t         	fFilterBit;            // Select tracks from an specific track cut (default 0xFF all track selected)
    UInt_t         	fSelectBit;            // Select events according to AliAnalysisTaskJetServices bit maps 
    Bool_t         	fUseChargeHadrons;     // Only use charge hadrons
    
    Int_t fSelectCharge;           // (un)like sign selection when building correlations: 0: no selection; 1: unlike sign; 2: like sign
    Float_t fTriggerRestrictEta;   // restrict eta range for trigger particle (default: -1 [off])
    
    Bool_t fFillpT;                // fill sum pT instead of number density
    
    ClassDef( AliAnalysisTaskPhiCorrelations, 4); // Analysis task for Underlying Event analysis w.r.t. leading track
  };

class AliDPhiBasicParticle : public AliVParticle
{
  public:
    AliDPhiBasicParticle(Float_t eta, Float_t phi, Float_t pt, Short_t charge)
      : fEta(eta), fPhi(phi), fpT(pt), fCharge(charge)
    {
    }
    ~AliDPhiBasicParticle() {}
    
    // kinematics
    virtual Double_t Px() const { AliFatal("Not implemented"); return 0; }
    virtual Double_t Py() const { AliFatal("Not implemented"); return 0; }
    virtual Double_t Pz() const { AliFatal("Not implemented"); return 0; }
    virtual Double_t Pt() const { return fpT; }
    virtual Double_t P() const { AliFatal("Not implemented"); return 0; }
    virtual Bool_t   PxPyPz(Double_t[3]) const { AliFatal("Not implemented"); return 0; }

    virtual Double_t Xv() const { AliFatal("Not implemented"); return 0; }
    virtual Double_t Yv() const { AliFatal("Not implemented"); return 0; }
    virtual Double_t Zv() const { AliFatal("Not implemented"); return 0; }
    virtual Bool_t   XvYvZv(Double_t[3]) const { AliFatal("Not implemented"); return 0; }

    virtual Double_t OneOverPt()  const { AliFatal("Not implemented"); return 0; }
    virtual Double_t Phi()        const { return fPhi; }
    virtual Double_t Theta()      const { AliFatal("Not implemented"); return 0; }


    virtual Double_t E()          const { AliFatal("Not implemented"); return 0; }
    virtual Double_t M()          const { AliFatal("Not implemented"); return 0; }
    
    virtual Double_t Eta()        const { return fEta; }
    virtual Double_t Y()          const { AliFatal("Not implemented"); return 0; }
    
    virtual Short_t Charge()      const { return fCharge; }
    virtual Int_t   GetLabel()    const { AliFatal("Not implemented"); return 0; }
    // PID
    virtual Int_t   PdgCode()     const { AliFatal("Not implemented"); return 0; }      
    virtual const Double_t *PID() const { AliFatal("Not implemented"); return 0; }
    
  private:
    Float_t fEta;      // eta
    Float_t fPhi;      // phi
    Float_t fpT;       // pT
    Short_t fCharge;   // charge
    
    ClassDef( AliDPhiBasicParticle, 1); // class which contains only quantities requires for this analysis to reduce memory consumption for event mixing
};
  
#endif
Commit	Line	Data
e0331fd9	1	#ifndef AliAnalysisTaskPhiCorrelations_H
	2	#define AliAnalysisTaskPhiCorrelations_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	// Analysis class for Underlying Event studies w.r.t. leading track
	10	//
	11	// Look for correlations on the tranverse regions w.r.t
	12	// the leading track in the event
	13	//
	14	// This class needs input AODs.
	15	// The output is a list of analysis-specific containers.
	16	//
	17	// The AOD can be either connected to the InputEventHandler
	18	// for a chain of AOD files
	19	// or
	20	// to the OutputEventHandler
	21	// for a chain of ESD files,
	22	// in this case the class should be in the train after the jet-finder
	23	//
	24	// Authors:
e0331fd9	25	// Jan Fiete Grosse-Oetringhaus
e0331fd9	26	//
	27	////////////////////////////////////////////////////////////////////////
	28
	29	#include "AliAnalysisTask.h"
	30	#include "AliUEHist.h"
2a910c25	31	#include "TString.h"
a1c31636	32	#include "AliVParticle.h"
a1c31636	33	#include "AliLog.h"
e0331fd9	34
	35	class AliAODEvent;
	36	class AliAnalyseLeadingTrackUE;
	37	class AliInputEventHandler;
	38	class AliMCEvent;
	39	class AliMCEventHandler;
	40	class AliUEHistograms;
	41	class AliVParticle;
	42	class TH1D;
	43	class TObjArray;
2a910c25	44	class AliEventPoolManager;
85bfac17	45	class AliESDEvent;
e0331fd9	46
	47	class AliAnalysisTaskPhiCorrelations : public AliAnalysisTask
	48	{
	49	public:
	50	AliAnalysisTaskPhiCorrelations(const char* name="AliAnalysisTaskPhiCorrelations");
	51	virtual ~AliAnalysisTaskPhiCorrelations();
	52
	53
	54	// Implementation of interace methods
	55	virtual void ConnectInputData(Option_t *);
	56	virtual void CreateOutputObjects();
	57	virtual void Exec(Option_t *option);
	58
	59	// Setters/Getters
	60	// general configuration
	61	virtual void SetDebugLevel( Int_t level ) { fDebug = level; }
	62	virtual void SetMode(Int_t mode) { fMode = mode; }
	63	virtual void SetReduceMemoryFootprint(Bool_t flag) { fReduceMemoryFootprint = flag; }
eed401dc	64	virtual void SetEventMixing(Bool_t flag) { fFillMixed = flag; }
ac647b0f	65	virtual void SetMixingTracks(Int_t tracks) { fMixingTracks = tracks; }
c3294f09	66	virtual void SetCompareCentralities(Bool_t flag) { fCompareCentralities = flag; }
1bba939a	67	virtual void SetTwoTrackEfficiencyStudy(Bool_t flag) { fTwoTrackEfficiencyStudy = flag; }
44af28f9	68	virtual void SetUseVtxAxis(Bool_t flag) { fUseVtxAxis = flag; }
e0331fd9	69
	70	// histogram settings
	71	void SetTrackingEfficiency( const TH1D* hist) { fkTrackingEfficiency = hist; }
	72
	73	// for event QA
	74	void SetTracksInVertex( Int_t val ){ fnTracksVertex = val; }
	75	void SetZVertex( Double_t val ) { fZVertex = val; }
	76
	77	// track cuts
	78	void SetTrackEtaCut( Double_t val ) { fTrackEtaCut = val; }
	79	void SetPtMin(Double_t val) { fPtMin = val; }
	80	void SetFilterBit( UInt_t val ) { fFilterBit = val; }
2a910c25	81
e0331fd9	82	void SetEventSelectionBit( UInt_t val ) { fSelectBit = val; }
e0331fd9	83	void SetUseChargeHadrons( Bool_t val ) { fUseChargeHadrons = val; }
2a910c25	84	void SetSelectCharge(Int_t selectCharge) { fSelectCharge = selectCharge; }
d38fa455	85	void SetTriggerRestrictEta(Float_t eta) { fTriggerRestrictEta = eta; }
2a910c25	86	void SetCentralityMethod(const char* method) { fCentralityMethod = method; }
c05ff6be	87	void SetFillpT(Bool_t flag) { fFillpT = flag; }
2a910c25	88
e0331fd9	89
	90	private:
	91	AliAnalysisTaskPhiCorrelations(const AliAnalysisTaskPhiCorrelations &det);
	92	AliAnalysisTaskPhiCorrelations& operator=(const AliAnalysisTaskPhiCorrelations &det);
	93	void AddSettingsTree(); // add list of settings to output list
	94	// Analysis methods
	95	void AnalyseCorrectionMode(); // main algorithm to get correction maps
	96	void AnalyseDataMode(); // main algorithm to get raw distributions
	97	void Initialize(); // initialize some common pointer
	98
	99
	100
	101	// General configuration
	102	Int_t fDebug; // Debug flag
	103	Int_t fMode; // fMode = 0: data-like analysis
	104	// fMode = 1: corrections analysis
	105	Bool_t fReduceMemoryFootprint; // reduce memory consumption by writing less debug histograms
eed401dc	106	Bool_t fFillMixed; // enable event mixing (default: ON)
ac647b0f	107	Int_t fMixingTracks; // size of track buffer for event mixing
c3294f09	108	Bool_t fCompareCentralities; // use the z vtx axis for a centrality comparison
1bba939a	109	Bool_t fTwoTrackEfficiencyStudy; // two-track efficiency study on
44af28f9	110	Bool_t fUseVtxAxis; // use z vtx as axis (needs 7 times more memory!)
e0331fd9	111
	112	// Pointers to external UE classes
	113	AliAnalyseLeadingTrackUE* fAnalyseUE; //! points to class containing common analysis algorithms
	114	AliUEHistograms* fHistos; //! points to class to handle histograms/containers
	115	AliUEHistograms* fHistosMixed; //! points to class to handle mixed histograms/containers
	116
	117	const TH1D* fkTrackingEfficiency; // used for study of bias by tracking
	118
	119	// Handlers and events
	120	AliAODEvent* fAOD; //! AOD Event
85bfac17	121	AliESDEvent* fESD; //! ESD Event
e0331fd9	122	TClonesArray* fArrayMC; //! Array of MC particles
	123	AliInputEventHandler* fInputHandler; //! Generic InputEventHandler
	124	AliMCEvent* fMcEvent; //! MC event
	125	AliMCEventHandler* fMcHandler; //! MCEventHandler
2a910c25	126	AliEventPoolManager* fPoolMgr; //! event pool manager
e0331fd9	127
	128	// Histogram settings
	129	TList* fListOfHistos; // Output list of containers
	130
	131	// Event QA cuts
c05ff6be	132	Int_t fnTracksVertex; // QA tracks pointing to principal vertex
e0331fd9	133	Double_t fZVertex; // Position of Vertex in Z direction
2a910c25	134	TString fCentralityMethod; // Method to determine centrality
e0331fd9	135
	136	// Track cuts
	137	Double_t fTrackEtaCut; // Eta cut on particles
	138	Double_t fPtMin; // Min pT to start correlations
	139	UInt_t fFilterBit; // Select tracks from an specific track cut (default 0xFF all track selected)
	140	UInt_t fSelectBit; // Select events according to AliAnalysisTaskJetServices bit maps
	141	Bool_t fUseChargeHadrons; // Only use charge hadrons
	142
2a910c25	143	Int_t fSelectCharge; // (un)like sign selection when building correlations: 0: no selection; 1: unlike sign; 2: like sign
d38fa455	144	Float_t fTriggerRestrictEta; // restrict eta range for trigger particle (default: -1 [off])
d38fa455	145
c05ff6be	146	Bool_t fFillpT; // fill sum pT instead of number density
2a910c25	147
d38fa455	148	ClassDef( AliAnalysisTaskPhiCorrelations, 4); // Analysis task for Underlying Event analysis w.r.t. leading track
e0331fd9	149	};
e0331fd9	150
a1c31636	151	class AliDPhiBasicParticle : public AliVParticle
	152	{
	153	public:
	154	AliDPhiBasicParticle(Float_t eta, Float_t phi, Float_t pt, Short_t charge)
	155	: fEta(eta), fPhi(phi), fpT(pt), fCharge(charge)
	156	{
	157	}
	158	~AliDPhiBasicParticle() {}
	159
	160	// kinematics
	161	virtual Double_t Px() const { AliFatal("Not implemented"); return 0; }
	162	virtual Double_t Py() const { AliFatal("Not implemented"); return 0; }
	163	virtual Double_t Pz() const { AliFatal("Not implemented"); return 0; }
	164	virtual Double_t Pt() const { return fpT; }
	165	virtual Double_t P() const { AliFatal("Not implemented"); return 0; }
	166	virtual Bool_t PxPyPz(Double_t[3]) const { AliFatal("Not implemented"); return 0; }
	167
	168	virtual Double_t Xv() const { AliFatal("Not implemented"); return 0; }
	169	virtual Double_t Yv() const { AliFatal("Not implemented"); return 0; }
	170	virtual Double_t Zv() const { AliFatal("Not implemented"); return 0; }
	171	virtual Bool_t XvYvZv(Double_t[3]) const { AliFatal("Not implemented"); return 0; }
	172
	173	virtual Double_t OneOverPt() const { AliFatal("Not implemented"); return 0; }
	174	virtual Double_t Phi() const { return fPhi; }
	175	virtual Double_t Theta() const { AliFatal("Not implemented"); return 0; }
	176
	177
	178	virtual Double_t E() const { AliFatal("Not implemented"); return 0; }
	179	virtual Double_t M() const { AliFatal("Not implemented"); return 0; }
	180
	181	virtual Double_t Eta() const { return fEta; }
	182	virtual Double_t Y() const { AliFatal("Not implemented"); return 0; }
	183
	184	virtual Short_t Charge() const { return fCharge; }
	185	virtual Int_t GetLabel() const { AliFatal("Not implemented"); return 0; }
	186	// PID
	187	virtual Int_t PdgCode() const { AliFatal("Not implemented"); return 0; }
	188	virtual const Double_t *PID() const { AliFatal("Not implemented"); return 0; }
	189
	190	private:
	191	Float_t fEta; // eta
	192	Float_t fPhi; // phi
	193	Float_t fpT; // pT
	194	Short_t fCharge; // charge
	195
	196	ClassDef( AliDPhiBasicParticle, 1); // class which contains only quantities requires for this analysis to reduce memory consumption for event mixing
	197	};
	198
e0331fd9	199	#endif
	200
	201