[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisTaskSE.h

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

/* $Id$ */

#include "AliAnalysisTask.h"
class AliVEvent;
class AliAODEvent;
class AliAODHeader;
class AliAODTracklets;
class AliAODCaloCells;
class AliMCEvent;
class AliInputEventHandler;
class AliAnalysisCuts;
class AliESDfriend;

class TTree;
class TList;


class AliAnalysisTaskSE : public AliAnalysisTask
{
 public:
    AliAnalysisTaskSE();
    AliAnalysisTaskSE(const char* name);
    AliAnalysisTaskSE(const AliAnalysisTaskSE& obj);
    AliAnalysisTaskSE& operator=(const AliAnalysisTaskSE& other);
    virtual ~AliAnalysisTaskSE() {;}
    // Implementation of interface methods
    virtual void   ConnectInputData(Option_t *option = "");
    virtual void   CreateOutputObjects();
    virtual void   Exec(Option_t* option);
    virtual void   SetDebugLevel(Int_t level) {fDebug = level;}
    virtual void   Init() {;}
    virtual Bool_t Notify();
    // To be implemented by user
    virtual void   UserCreateOutputObjects()  {;}
    virtual void   UserExec(Option_t* /*option*/) {;}
    virtual Bool_t UserNotify() {return kTRUE;}
    virtual void   NotifyRun()  {;}
    
    // Helpers for adding branches to the AOD
    virtual void   AddAODBranch(const char* cname, void* addobj, const char *fname="");
    // Event Selection
    virtual void   SelectCollisionCandidates() {fSelectCollisions = kTRUE;}
 // Getters
    virtual Int_t         DebugLevel()  {return fDebug;     }
    virtual AliVEvent*    InputEvent()  {return fInputEvent;}
    virtual AliESDfriend* ESDfriend()   {return fESDfriend; }
    virtual AliAODEvent*  AODEvent()    {return fOutputAOD; }
    virtual TTree*        OutputTree()  {return fTreeA;     }
    virtual AliMCEvent*   MCEvent()     {return fMCEvent;   }
    virtual Long64_t      Entry()       {return fEntry;     }
    virtual const char*   CurrentFileName();
    virtual Bool_t        IsStandardAOD() const;
    virtual TList*        GetQAHistos()   const {return fHistosQA;}
    virtual Bool_t        IsEventInBinZero() { return kFALSE;}

  protected:
    Int_t                 fDebug;           //  Debug flag
    // IO
    Int_t                 fEntry;           //  Current entry in the chain
    AliVEvent*            fInputEvent;      //! VEvent Input
    AliESDfriend*         fESDfriend;       //! ESD friend
    AliInputEventHandler* fInputHandler;    //! Input Handler
    AliAODEvent*          fOutputAOD;       //! AOD out 
    AliMCEvent*           fMCEvent;         //! MC
    TTree*                fTreeA;           //  AOD output Tree
    Int_t                 fCurrentRunNumber;//! Current run number
    // Output histos for QA
    TList*                fHistosQA;        //! Output histos for QA
    // Provisions for replication
    static AliAODHeader*    fgAODHeader;        //! Header for replication
    static TClonesArray*    fgAODTracks;        //! Tracks for replication
    static TClonesArray*    fgAODVertices;      //! Vertices for replication
    static TClonesArray*    fgAODV0s;           //! V0s for replication
    static TClonesArray*    fgAODPMDClusters;   //! PMDClusters for replication
    static TClonesArray*    fgAODJets;          //! Jets for replication
    static TClonesArray*    fgAODFMDClusters;   //! FMDClusters for replication
    static TClonesArray*    fgAODCaloClusters;  //! CaloClusters for replication
    static TClonesArray*    fgAODMCParticles;   //! MC Particles for replicatio
    static AliAODTracklets* fgAODTracklets;     //! Tracklets for replication
    static AliAODCaloCells* fgAODEmcalCells;    //! Emcal Cell replication
    static AliAODCaloCells* fgAODPhosCells;     //! Phos  Cell replication
    static TClonesArray*    fgAODDimuons;       //! Dimuons replication
    // Event Selection
    Bool_t                  fSelectCollisions;   //  Task processes collision candidates only
     
    ClassDef(AliAnalysisTaskSE, 3); // Analysis task for standard jet analysis
};
 
#endif
Commit	Line	Data
5232d0de	1	#ifndef ALIANALYSISTASKSE_H
	2	#define ALIANALYSISTASKSE_H
	3
	4	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	5	* See cxx source for full Copyright notice */
	6
	7	/* $Id$ */
	8
	9	#include "AliAnalysisTask.h"
	10	class AliVEvent;
	11	class AliAODEvent;
3f2431c4	12	class AliAODHeader;
c185e0db	13	class AliAODTracklets;
5a922844	14	class AliAODCaloCells;
5232d0de	15	class AliMCEvent;
80d13558	16	class AliInputEventHandler;
f0ee78b0	17	class AliAnalysisCuts;
620ad672	18	class AliESDfriend;
5a922844	19
5232d0de	20	class TTree;
1ec2c8dc	21	class TList;
5232d0de	22
	23
	24	class AliAnalysisTaskSE : public AliAnalysisTask
	25	{
	26	public:
	27	AliAnalysisTaskSE();
	28	AliAnalysisTaskSE(const char* name);
26f071d8	29	AliAnalysisTaskSE(const AliAnalysisTaskSE& obj);
26f071d8	30	AliAnalysisTaskSE& operator=(const AliAnalysisTaskSE& other);
5232d0de	31	virtual ~AliAnalysisTaskSE() {;}
5232d0de	32	// Implementation of interface methods
f0ee78b0	33	virtual void ConnectInputData(Option_t *option = "");
	34	virtual void CreateOutputObjects();
	35	virtual void Exec(Option_t* option);
	36	virtual void SetDebugLevel(Int_t level) {fDebug = level;}
	37	virtual void Init() {;}
1ec2c8dc	38	virtual Bool_t Notify();
5232d0de	39	// To be implemented by user
f0ee78b0	40	virtual void UserCreateOutputObjects() {;}
f0ee78b0	41	virtual void UserExec(Option_t* /option/) {;}
1ec2c8dc	42	virtual Bool_t UserNotify() {return kTRUE;}
1ec2c8dc	43	virtual void NotifyRun() {;}
f0ee78b0	44
164e94ff	45	// Helpers for adding branches to the AOD
f0ee78b0	46	virtual void AddAODBranch(const char* cname, void* addobj, const char *fname="");
	47	// Event Selection
	48	virtual void SelectCollisionCandidates() {fSelectCollisions = kTRUE;}
bf666461	49	// Getters
620ad672	50	virtual Int_t DebugLevel() {return fDebug; }
	51	virtual AliVEvent* InputEvent() {return fInputEvent;}
	52	virtual AliESDfriend* ESDfriend() {return fESDfriend; }
	53	virtual AliAODEvent* AODEvent() {return fOutputAOD; }
	54	virtual TTree* OutputTree() {return fTreeA; }
	55	virtual AliMCEvent* MCEvent() {return fMCEvent; }
	56	virtual Long64_t Entry() {return fEntry; }
	57	virtual const char* CurrentFileName();
	58	virtual Bool_t IsStandardAOD() const;
	59	virtual TList* GetQAHistos() const {return fHistosQA;}
85c71ba7	60	virtual Bool_t IsEventInBinZero() { return kFALSE;}
85c71ba7	61
80d13558	62	protected:
80d13558	63	Int_t fDebug; // Debug flag
1ec2c8dc	64	// IO
80d13558	65	Int_t fEntry; // Current entry in the chain
80d13558	66	AliVEvent* fInputEvent; //! VEvent Input
620ad672	67	AliESDfriend* fESDfriend; //! ESD friend
80d13558	68	AliInputEventHandler* fInputHandler; //! Input Handler
	69	AliAODEvent* fOutputAOD; //! AOD out
	70	AliMCEvent* fMCEvent; //! MC
	71	TTree* fTreeA; // AOD output Tree
1ec2c8dc	72	Int_t fCurrentRunNumber;//! Current run number
	73	// Output histos for QA
	74	TList* fHistosQA; //! Output histos for QA
	75	// Provisions for replication
c185e0db	76	static AliAODHeader* fgAODHeader; //! Header for replication
	77	static TClonesArray* fgAODTracks; //! Tracks for replication
	78	static TClonesArray* fgAODVertices; //! Vertices for replication
	79	static TClonesArray* fgAODV0s; //! V0s for replication
	80	static TClonesArray* fgAODPMDClusters; //! PMDClusters for replication
	81	static TClonesArray* fgAODJets; //! Jets for replication
	82	static TClonesArray* fgAODFMDClusters; //! FMDClusters for replication
	83	static TClonesArray* fgAODCaloClusters; //! CaloClusters for replication
113bc2bd	84	static TClonesArray* fgAODMCParticles; //! MC Particles for replicatio
c185e0db	85	static AliAODTracklets* fgAODTracklets; //! Tracklets for replication
5a922844	86	static AliAODCaloCells* fgAODEmcalCells; //! Emcal Cell replication
5a922844	87	static AliAODCaloCells* fgAODPhosCells; //! Phos Cell replication
866d8d78	88	static TClonesArray* fgAODDimuons; //! Dimuons replication
bf666461	89	// Event Selection
f0ee78b0	90	Bool_t fSelectCollisions; // Task processes collision candidates only
f0ee78b0	91
866d8d78	92	ClassDef(AliAnalysisTaskSE, 3); // Analysis task for standard jet analysis
5232d0de	93	};
	94
	95	#endif