[u/mrichter/AliRoot.git] / STEER / AliInputEventHandler.h

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

/* $Id$ */

//-------------------------------------------------------------------------
//     Input Handler realisation of the AliVEventHandler interface
//     Author: Andreas Morsch, CERN
//-------------------------------------------------------------------------

#include "AliVEventHandler.h"
#include <TTree.h>


class AliVEvent;
class AliVCuts;
class AliRunTag;


class AliInputEventHandler : public AliVEventHandler {

 public:
 enum EInputHandlerFlags {
    kUserCallSelectionMask = BIT(14) // Watch out for defining base class bits
 };
    AliInputEventHandler();
    AliInputEventHandler(const char* name, const char* title);
    virtual ~AliInputEventHandler();
    virtual void         SetOutputFileName(const char* /*fname*/) {;}
    virtual const char  *GetOutputFileName()                          {return 0;}
    virtual Bool_t       Init(Option_t* /*opt*/)                      {return kTRUE;}
    virtual Bool_t       Init(TTree* /*tree*/, Option_t* /*opt*/)     {return kTRUE;}
    virtual Bool_t       GetEntry() {if(fMixingHandler) fMixingHandler->GetEntry(); return kTRUE;}
    
    virtual Bool_t       BeginEvent(Long64_t /*entry*/)               {return kTRUE;}
    virtual Bool_t       Notify() { return AliVEventHandler::Notify();}
    virtual Bool_t       Notify(const char */*path*/)                 {return kTRUE;}
    virtual Bool_t       FinishEvent()                                {return kTRUE;}        
    virtual Bool_t       Terminate()                                  {return kTRUE;}
    virtual Bool_t       TerminateIO()                                {return kTRUE;}
    // Setters
    virtual void         SetInputTree(TTree* tree)                    {fTree = tree;}
    virtual void         SetEventSelection(AliVCuts* cuts)            {fEventCuts = cuts;}
    virtual void         SetUserCallSelectionMask(Bool_t flag=kTRUE)  {TObject::SetBit(kUserCallSelectionMask,flag);}
    //
    void SetInactiveBranches(const char* branches) {fBranches   = branches;}
    void SetActiveBranches  (const char* branches) {fBranchesOn = branches;}
     // Getters
    virtual AliVEvent   *GetEvent()        const                      {return 0;}
    virtual AliRunTag   *GetRunTag()       const                      {return 0;}
    virtual Option_t    *GetAnalysisType() const                      {return 0;}
    virtual TTree       *GetTree( )        const                      {return fTree;}
    virtual AliVCuts    *GetEventSelection() const                    {return fEventCuts;}
    virtual Long64_t     GetReadEntry()    const;
    virtual Bool_t       IsUserCallSelectionMask() const              {return TObject::TestBit(kUserCallSelectionMask);}
    virtual Bool_t       NewEvent()
	{Bool_t ne = fNewEvent; fNewEvent = kFALSE; return ne;}
    virtual UInt_t       IsEventSelected() 
        {return fIsSelectedResult;}
    // Mixing
    void SetMixingHandler(AliInputEventHandler* mixing) 
    {fMixingHandler = mixing;}
    AliInputEventHandler* MixingHandler()
    {return fMixingHandler;}

 protected:
    void SwitchOffBranches() const;
    void SwitchOnBranches()  const;
 private:
    AliInputEventHandler(const AliInputEventHandler& handler);             
    AliInputEventHandler& operator=(const AliInputEventHandler& handler);  
 protected:
    TTree          *fTree;         //! Pointer to the tree
    TString         fBranches;     //  List of branches to be switched off (separated by space)
    TString         fBranchesOn;   //  List of branches to be switched on  (separated by space)
    Bool_t          fNewEvent;     //  New event flag 
    AliVCuts*       fEventCuts;    //  Cuts on the event level
    UInt_t          fIsSelectedResult; //  Selection result
    AliInputEventHandler* fMixingHandler; // Optionla plugin for mixing 
    ClassDef(AliInputEventHandler, 5);
};

#endif
Commit	Line	Data
76147823	1	#ifndef ALIINPUTEVENTHANDLER_H
	2	#define ALIINPUTEVENTHANDLER_H
	3	/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	//-------------------------------------------------------------------------
	9	// Input Handler realisation of the AliVEventHandler interface
	10	// Author: Andreas Morsch, CERN
	11	//-------------------------------------------------------------------------
	12
	13	#include "AliVEventHandler.h"
97acfdbe	14	#include <TTree.h>
97acfdbe	15
76147823	16
76147823	17	class AliVEvent;
b2af62ab	18	class AliVCuts;
1aa09fd1	19	class AliRunTag;
76147823	20
b2af62ab	21
76147823	22	class AliInputEventHandler : public AliVEventHandler {
	23
	24	public:
aaf2d706	25	enum EInputHandlerFlags {
	26	kUserCallSelectionMask = BIT(14) // Watch out for defining base class bits
	27	};
76147823	28	AliInputEventHandler();
	29	AliInputEventHandler(const char* name, const char* title);
	30	virtual ~AliInputEventHandler();
0931e76a	31	virtual void SetOutputFileName(const char* /fname/) {;}
0931e76a	32	virtual const char *GetOutputFileName() {return 0;}
300d5701	33	virtual Bool_t Init(Option_t* /opt/) {return kTRUE;}
87d395bd	34	virtual Bool_t Init(TTree* /tree/, Option_t* /opt/) {return kTRUE;}
0d6a82a5	35	virtual Bool_t GetEntry() {if(fMixingHandler) fMixingHandler->GetEntry(); return kTRUE;}
0d6a82a5	36
300d5701	37	virtual Bool_t BeginEvent(Long64_t /entry/) {return kTRUE;}
f0ee78b0	38	virtual Bool_t Notify() { return AliVEventHandler::Notify();}
300d5701	39	virtual Bool_t Notify(const char /path*/) {return kTRUE;}
	40	virtual Bool_t FinishEvent() {return kTRUE;}
	41	virtual Bool_t Terminate() {return kTRUE;}
	42	virtual Bool_t TerminateIO() {return kTRUE;}
76147823	43	// Setters
300d5701	44	virtual void SetInputTree(TTree* tree) {fTree = tree;}
b2af62ab	45	virtual void SetEventSelection(AliVCuts* cuts) {fEventCuts = cuts;}
aaf2d706	46	virtual void SetUserCallSelectionMask(Bool_t flag=kTRUE) {TObject::SetBit(kUserCallSelectionMask,flag);}
f16ba708	47	//
	48	void SetInactiveBranches(const char* branches) {fBranches = branches;}
	49	void SetActiveBranches (const char* branches) {fBranchesOn = branches;}
fedd7a0d	50	// Getters
1aa09fd1	51	virtual AliVEvent *GetEvent() const {return 0;}
	52	virtual AliRunTag *GetRunTag() const {return 0;}
	53	virtual Option_t *GetAnalysisType() const {return 0;}
	54	virtual TTree *GetTree( ) const {return fTree;}
2af85599	55	virtual AliVCuts *GetEventSelection() const {return fEventCuts;}
f0ee78b0	56	virtual Long64_t GetReadEntry() const;
aaf2d706	57	virtual Bool_t IsUserCallSelectionMask() const {return TObject::TestBit(kUserCallSelectionMask);}
f0ee78b0	58	virtual Bool_t NewEvent()
f0ee78b0	59	{Bool_t ne = fNewEvent; fNewEvent = kFALSE; return ne;}
0c6c629b	60	virtual UInt_t IsEventSelected()
0c6c629b	61	{return fIsSelectedResult;}
8ed10396	62	// Mixing
	63	void SetMixingHandler(AliInputEventHandler* mixing)
	64	{fMixingHandler = mixing;}
	65	AliInputEventHandler* MixingHandler()
	66	{return fMixingHandler;}
	67
f16ba708	68	protected:
	69	void SwitchOffBranches() const;
	70	void SwitchOnBranches() const;
87d395bd	71	private:
	72	AliInputEventHandler(const AliInputEventHandler& handler);
	73	AliInputEventHandler& operator=(const AliInputEventHandler& handler);
76147823	74	protected:
f16ba708	75	TTree *fTree; //! Pointer to the tree
	76	TString fBranches; // List of branches to be switched off (separated by space)
	77	TString fBranchesOn; // List of branches to be switched on (separated by space)
f0ee78b0	78	Bool_t fNewEvent; // New event flag
b2af62ab	79	AliVCuts* fEventCuts; // Cuts on the event level
0c6c629b	80	UInt_t fIsSelectedResult; // Selection result
b890a10d	81	AliInputEventHandler* fMixingHandler; // Optionla plugin for mixing
21679a94	82	ClassDef(AliInputEventHandler, 5);
76147823	83	};
	84
	85	#endif