FrameDispatcher.h

Go to the documentation of this file.

#ifndef Gw_FrameDispatcher
#define Gw_FrameDispatcher

// Gw includes
#ifndef Gw_Watchers
#include "Watchers.h"
#include "TTreeWatchers.h"
#endif

// ADF includes
#ifndef ADF_Trigger
#include "Trigger.h"
#endif
#ifndef ADF_NarvalInterface
#include "NarvalInterface.h"
#endif

// ROOT includes
#include "TH1.h"
#include "TStopwatch.h"
#include "TROOT.h"

// standard includes
#include <vector>

namespace Gw {


class FrameDispatcher : public Watcher, public ADF::NarvalConsumer 
{       
private:
        static Short_t gDoTimer;
        
private:
        ADF::PtrStack<ADF::DFTrigger> fListOfTriggers;
        
protected:
        TStopwatch fTimeControl;
        
private:
        static const UInt_t kMaxCycle = 1000u;
        UInt_t fWhichBin;       
        
private:        
        TH1D *fTriggerRate;
        TH1F *fBufferSize;      
        TList *fRealTime;
        TList *fCPUTime;
        
        std::vector< std::pair<Double_t, Double_t> > fCurrentValues;
        
protected:
        virtual void DoCanvas(TCanvas *c, Option_t *);
        
        // void BeginOfBlock();
        // void EndOfBlock();
        
public:
        FrameDispatcher();
        FrameDispatcher(const char *, const char *, TDirectory *mother_watcher_dir = 0x0, TDirectory *mother_tag_watcher_dir = 0x0);
        virtual ~FrameDispatcher();


        static Short_t DoTimer(Short_t dotimer)
        {
                Short_t old = gDoTimer;
                switch (dotimer) {
                        case 0:
                        case 1:
                                gDoTimer = dotimer;
                                break;                          
                        default:
                                gDoTimer = 2;
                                break;
                }
                return old;
        }
                
        virtual void process_initialise (UInt_t */*error_code*/)
                {;}
                
        virtual void process_reset (UInt_t */*error_code*/)     
                {;}     
                
        virtual UInt_t ProcessBlock (ADF::FrameBlock &);
        

        virtual Bool_t SetTrigger(ADF::DFTrigger *);

        template<typename Watcher_T> Watcher_T * Add(const Char_t *name, const Char_t *title, ADF::DFTrigger *t = 0x0)
        {
                //set the watcher. Directories are set in Add since no need to have them at construction to load spectra
                Watcher_T *watcher = new Watcher_T(name,title); 
                
                if ( t ) 
                        Add( watcher , t );     
                else 
                        Add( watcher );
                
                return watcher;
        }

    TTreeMaster *AddTreeMaster(const Char_t *name, const Char_t *title, Bool_t Overwrite = false, ADF::DFTrigger *t = 0x0)
    {
        //set the watcher. Directories are set in Add since no need to have them at construction to load spectra
        TTreeMaster *watcher = new TTreeMaster(name,title,2,2,Overwrite);

        if ( t )
            Add( watcher , t );
        else
            Add( watcher );

        return watcher;
    }

        
        virtual void SetDirectory(TDirectory *mother_dir_of_watcher, TDirectory *mother_dir_for_tag, Bool_t load_objects = true);
        
        virtual void Add(TTask *);
        

        virtual void Add(Watcher *, ADF::DFTrigger *);  
        
        virtual void Zero(Option_t * hname = "pool", Option_t *binning="");  //*MENU*

    virtual void Print(Option_t * /*option*/ ="") const {;}  //*MENU*
                
        ClassDef(FrameDispatcher,0) // From a block, dispatchs specific Triggers to other Watchers
};

} // end namespace

#endif