Line data    Source code

       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             : #include "AliVEvent.h"
      11             : 
      12             : class AliAODEvent;
      13             : class AliAODHeader;
      14             : class AliTOFHeader;
      15             : class AliAODVZERO;
      16             : class AliAODTracklets;
      17             : class AliAODCaloCells;
      18             : class AliAODCaloTrigger;
      19             : class AliMCEvent;
      20             : class AliMCEventHandler;
      21             : class AliInputEventHandler;
      22             : class AliMultiInputEventHandler;
      23             : class AliAnalysisCuts;
      24             : class AliESDfriend;
      25             : class AliEventTag;
      26             : class AliTrackSelectionFactory;
      27             : class AliVTrackSelection;
      28             : 
      29             : class TTree;
      30             : class TList;
      31             : 
      32             : 
      33             : class AliAnalysisTaskSE : public AliAnalysisTask
      34             : {
      35             :  public:
      36             :     AliAnalysisTaskSE();
      37             :     AliAnalysisTaskSE(const char* name);
      38             :     AliAnalysisTaskSE(const AliAnalysisTaskSE& obj);
      39             :     AliAnalysisTaskSE& operator=(const AliAnalysisTaskSE& other);
      40           0 :     virtual ~AliAnalysisTaskSE() {;}
      41             :     // Implementation of interface methods
      42             :     virtual void   ConnectInputData(Option_t *option = "");
      43             :     virtual void   CreateOutputObjects();
      44             :     virtual void   Exec(Option_t* option);
      45           0 :     virtual void   SetDebugLevel(Int_t level) {fDebug = level;}
      46           0 :     virtual void   Init() {;}
      47             :     virtual Bool_t Notify();
      48             :     // To be implemented by user
      49           0 :     virtual void   UserCreateOutputObjects()  {;}
      50           0 :     virtual void   UserExec(Option_t* /*option*/) {;}
      51           0 :     virtual void   UserExecMix(Option_t */*option*/) {;}
      52           0 :     virtual Bool_t UserNotify() {return kTRUE;}
      53           6 :     virtual void   NotifyRun()  {;}
      54             :     
      55             :     // Helpers for adding branches to the AOD
      56             :     virtual void   AddAODBranch(const char* cname, void* addobj, const char *fname="");
      57             :     // Event Selection
      58           0 :     virtual void   SelectCollisionCandidates(UInt_t offlineTriggerMask = AliVEvent::kMB) {fOfflineTriggerMask = offlineTriggerMask;}
      59             :     // Loading the declared input branches
      60             :     void           LoadBranches() const;
      61             :  // Getters
      62           0 :     virtual Int_t         DebugLevel() const  {return fDebug;     }
      63          86 :     virtual AliVEvent*    InputEvent() const  {return fInputEvent;}
      64           0 :     virtual AliESDfriend* ESDfriend()  const  {return fESDfriend; }
      65        5360 :     virtual AliAODEvent*  AODEvent()   const  {return fOutputAOD; }
      66          26 :     virtual TTree*        OutputTree() const  {return fTreeA;     }
      67          24 :     virtual AliMCEvent*   MCEvent()    const  {return fMCEvent;   }
      68          56 :     virtual Long64_t      Entry()      const  {return fEntry;     }
      69             :     virtual const AliEventTag *EventTag() const;
      70             :     virtual const char*   CurrentFileName();
      71             :     virtual Bool_t        IsStandardAOD() const;
      72           0 :     virtual TList*        GetQAHistos()   const {return fHistosQA;}
      73           0 :     virtual Bool_t        IsEventInBinZero() { return kFALSE;}
      74           0 :     virtual UInt_t        GetCollisionCandidates() const { return fOfflineTriggerMask;}
      75             : 
      76           0 :     void SetTrackSelectionFactory(AliTrackSelectionFactory *factory)  { fTrackSelectionFactory = factory; }
      77           0 :     void SetTrackSelection(AliVTrackSelection *sel)                   { fTrackSelection = sel; }
      78             : 
      79             :  protected:
      80             :     void ConnectMultiHandler();
      81             :     void DisconnectMultiHandler();
      82             : 
      83             :     TObjArray *GetAcceptedTracks();
      84             : 
      85             :   protected:
      86             :     Int_t                 fDebug;           //  Debug flag
      87             :     // IO
      88             :     Int_t                 fEntry;           //  Current entry in the chain
      89             :     AliVEvent*            fInputEvent;      //! VEvent Input
      90             :     AliESDfriend*         fESDfriend;       //! ESD friend
      91             :     AliInputEventHandler* fInputHandler;    //! Input Handler
      92             :     AliAODEvent*          fOutputAOD;       //! AOD out 
      93             :     AliMCEvent*           fMCEvent;         //! MC
      94             :     TTree*                fTreeA;           //  AOD output Tree
      95             :     Int_t                 fCurrentRunNumber;//! Current run number
      96             :     // Output histos for QA
      97             :     TList*                fHistosQA;        //! Output histos for QA
      98             :     // Provisions for replication
      99             :     static AliVHeader*      fgAODHeader;        //! Header for replication
     100             :     static AliTOFHeader*    fgTOFHeader;        //! TOFHeader for replication
     101             :     static AliAODVZERO*     fgAODVZERO;         //! VZERO for replication
     102             :     static TClonesArray*    fgAODTracks;        //! Tracks for replication
     103             :     static TClonesArray*    fgAODVertices;      //! Vertices for replication
     104             :     static TClonesArray*    fgAODV0s;           //! V0s for replication
     105             :     static TClonesArray*    fgAODPMDClusters;   //! PMDClusters for replication
     106             :     static TClonesArray*    fgAODJets;          //! Jets for replication
     107             :     static TClonesArray*    fgAODFMDClusters;   //! FMDClusters for replication
     108             :     static TClonesArray*    fgAODCaloClusters;  //! CaloClusters for replication
     109             :     static AliAODCaloTrigger* fgAODEMCALTrigger; //! Emcal Trigger for replication
     110             :     static AliAODCaloTrigger* fgAODPHOSTrigger;  //! Phos Trigger for replication
     111             :     static TClonesArray*    fgAODMCParticles;   //! MC Particles for replicatio
     112             :     static AliAODTracklets* fgAODTracklets;     //! Tracklets for replication
     113             :     static AliAODCaloCells* fgAODEmcalCells;    //! Emcal Cell replication
     114             :     static AliAODCaloCells* fgAODPhosCells;     //! Phos  Cell replication
     115             :     static TClonesArray*    fgAODDimuons;       //! Dimuons replication
     116             :     static TClonesArray*    fgAODHmpidRings;    //! HMPID replication
     117             :     // Event Selection
     118             :     UInt_t fOfflineTriggerMask;   //  Task processes collision candidates only
     119             :     // Event Mixing
     120             :     AliMultiInputEventHandler *fMultiInputHandler;  //! pointer to multihandler
     121             :     AliInputEventHandler      *fMCEventHandler;     //! pointer to MCEventHandler
     122             :     AliTrackSelectionFactory  *fTrackSelectionFactory; /// track selection factory
     123             :     AliVTrackSelection        *fTrackSelection;        /// track selection
     124         170 :     ClassDef(AliAnalysisTaskSE, 5); // Analysis task for standard jet analysis
     125             : };
     126             :  
     127             : #endif