Watchers.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef Gw_Watchers
#define Gw_Watchers

// ADF includes
#include "NarvalInterface.h"
#include "Trigger.h"
#include "GwLogMessage.h"

// ROOT includes
#include "TTask.h"
#include "TStopwatch.h"
#include "TObjArray.h"
#include "TCanvas.h"
#include "TFile.h"
#include "TH1.h"
#include "TTimer.h"
#include "TROOT.h"
#include "TFolder.h"

namespace Gw {


class Watcher : public TTask 
{       
public:
    static const TList *GetListOfWatchers(){return fgListOfWatchers;}
        
private:
        static TList *fgListOfWatchers;

        static void Register(Watcher *, Option_t *opt = "+");
        
public:

        static Watcher *GetLastRegistered(const Char_t *classname, Option_t *opt = "baseclass");
public:
        static void SetFirst(Watcher *);
        
protected:
        mutable LogMessage fLog; 
        
private:
        static Bool_t fgDeletePool;
        
private:
        Bool_t fDeletePool;
        
        TObjArray fPoolOfObjects;
        TObjArray fTagged;
        TObjArray fReference;   
        
protected:
        TDirectory *fDirectory; 
        TDirectory *fTagDirectory; 
        TFolder *fTopFolder;
        
private:
        Short_t fLastExecStatus;
        
protected:
        ADF::DFTrigger *fTrigger;
        
protected:

        // TString fKind;
        
protected:

        void LoadObject(TObject *new_obj, TDirectory *root_dir);
        

        TObject *AddToPool(TObject *ob);
        

        TCanvas *NewCanvas(Option_t *);
        
        void DirToDir(TDirectory *, TDirectory *, TObjArray &, Bool_t load_objects = true);
        void RemoveFromDir(TObject *, TDirectory *);
        void AddToDir(TObject *, TDirectory *);
        Bool_t MakeDir(TFolder *f, TDirectory *mother_dir, Bool_t do_top = true);  
        /*
                In case of success, path has the form a/b/c/
                Otherwise empty string. The path is not reset, the user gas to give an empty one 
         */
        Bool_t GetPathOf(TFolder *f, TObject *searched, TString &path);
        
protected:
//      TDirectory * GetSubFolder(const Char_t *sub = "");
        TFolder *GetSubFolder(TFolder *topfolder, const Char_t *sub = "");
        
        template <typename Histo_T> Histo_T *
                MakeTH1(const Char_t *hname, const Char_t *htitle, Int_t binx, Double_t xmin, Double_t xmax, const Char_t *sub = "")
        {
                Bool_t def = TH1::AddDirectoryStatus();
                TH1::AddDirectory(false);       
                
                Histo_T *h = 0x0; TString subfolder = sub; 
                //
                h = new Histo_T(hname,htitle,binx,xmin,xmax);
                if ( h ) {
                        TFolder *folder = GetSubFolder(fTopFolder,sub);
                        folder->Add((TObject *)h); 
                        AddToPool(h);
                        // does not belong to directory
                        h->SetDirectory(0);
                }
                TH1::AddDirectory(def);         
                
                return h;
        }
        template <typename Histo_T> Histo_T *   
                MakeTH2(const Char_t *hname, const Char_t *htitle, 
                                  Int_t binx, Double_t xmin, Double_t xmax, 
                                  Int_t biny, Double_t ymin, Double_t ymax, 
                                  const Char_t *sub = "")
        {
                Bool_t def = TH1::AddDirectoryStatus();
                TH1::AddDirectory(false);       
                
                Histo_T *h = 0x0; TString subfolder = sub; 
                //
                h = new Histo_T(hname,htitle,binx,xmin,xmax,biny,ymin,ymax);
                if ( h ) {
                        TFolder *folder = GetSubFolder(fTopFolder,sub);
                        folder->Add(h); 
                        AddToPool(h);
                        // does not belong to directory
                        h->SetDirectory(0);
                }
                TH1::AddDirectory(def);         

                return h;
        }       
        template <typename Histo_T> Histo_T *
                MakeTH3(const Char_t *hname, const Char_t *htitle, 
                                  Int_t binx, Double_t xmin, Double_t xmax, 
                                  Int_t biny, Double_t ymin, Double_t ymax, 
                                  Int_t binz, Double_t zmin, Double_t zmax,                               
                                  const Char_t *sub = "")
        {
                Bool_t def = TH1::AddDirectoryStatus();
                TH1::AddDirectory(false);       
                
                Histo_T *h = 0x0; TString subfolder = sub; 
                //
                h = new Histo_T(hname,htitle,binx,xmin,xmax,biny,ymin,ymax,binz,zmin,zmax);
                if ( h ) {
                        TFolder *folder = GetSubFolder(fTopFolder,sub);
                        folder->Add(h); 
                        AddToPool(h);
                        // does not belong to directory
                        h->SetDirectory(0);
                }
                TH1::AddDirectory(def);         

                return h;
        }       
        
protected:
        void TagOn(TObject *);
        
        void DrawTag(TCanvas *, Option_t *);    
        
protected:      
        virtual void DoCanvas(TCanvas *, Option_t *)
                { ; }
        

        Bool_t GetFromTrigger(ADF::DFTrigger *, const char *, ADF::SharedFP *&);                
        
public:
        Watcher();      
        Watcher(const char *name, const char *title, TDirectory *mother_dir_of_watcher = 0x0, TDirectory *mother_dir_tag = 0x0);
        virtual ~Watcher();
        
        virtual void CleanTasks();
        
        /*
        void SetKind(const char *kind)
        {
                fKind = kind;
        }
        
        Bool_t IsKind(const char *kind) const
        {
                return fKind.Contains(kind);
        }
         */
        

        virtual UInt_t Snapshot(Option_t * = "*"); //*MENU*
        
        void SetLastError(Short_t s = 0)
        { fLastExecStatus = s ; }
        Short_t GetLastError() const
        { return fLastExecStatus ; }            
        
        void SetLastExecStatus(Short_t s = 0)
        { 
                fLastExecStatus = s ; 
        }
        
        Short_t GetLastExecStatus() const
        { 
                return fLastExecStatus ; 
        }               
                
        //virtual TDirectory *GetDirectory(Option_t * /*opt*/ = "")
        //      { return fDirectory; }
        virtual TDirectory *GetDirectory(Option_t * opt = "")
        { 
                TString o = opt; 
                if ( o.Contains("tag") ) 
                        return fTagDirectory; 
                return fDirectory; 
        }
        
        virtual TObjArray &GetPoolOfObject()
                { return fPoolOfObjects; }
        virtual TObjArray &GetReference()
                { return fReference; }
        

        virtual void SetDirectory(TDirectory *mother_dir_of_watcher, TDirectory *mother_dir_tag, Bool_t load_objects = true);
                

        void Pass();
        
        virtual void Continue() 
                {;}     
        virtual void Abort() 
                {;}     
        virtual void SetBreakin(Int_t /*breakin*/ = 1) 
                {;}
        virtual void SetBreakout(Int_t /*breakout*/ = 1)
                {;}


        virtual void Add(TTask *);


        virtual Bool_t SetTrigger(ADF::DFTrigger *);
                
        virtual ADF::DFTrigger *GetTrigger() const
                { return fTrigger; }
  
        static void SetGlobalDeletePool(Bool_t d) 
                { fgDeletePool = d; }
  
        virtual void SetDeletePool(Bool_t d) 
                { fDeletePool = d; }
  
        virtual Bool_t GetDeletePool() const 
                { return fDeletePool; }
        
        // virtual void Exec(Option_t *option="") 
        

        virtual void Zero(Option_t *hname="pool", Option_t *binning="");  //*MENU*
        
        void ShowCanvas(Option_t *option="") ; //*MENU*
        
        virtual Bool_t TestTag(Option_t *opt);   //*MENU*
        
    virtual void Tag(Option_t *opt = ""); //*MENU*
        
        ClassDef(Watcher,0)  // base class for a watcher
};

class WatcherWithTag : public Watcher
{       
private:
        //TObjArray fTagged;
        //TObjArray fReference; 
        
protected:
        //TObjArray &GetReference()
        //      { return fReference; }
        
protected:
//      TDirectory *fTagDirectory; //!
        
protected:
        //void TagOn(TObject *);
        
        //void DrawTag(TCanvas *, Option_t *);
        
public:
        WatcherWithTag();       
        WatcherWithTag(const char *name, const char *title, TDirectory *mother_dir_of_watcher, TDirectory *mother_dir_tag);
        virtual ~WatcherWithTag() 
                {;}
        

        // virtual void SetDirectory(TDirectory *mother_dir_of_watcher, TDirectory *mother_dir_tag = 0x0, Bool_t load_objects = true);

        //virtual TDirectory *GetDirectory(Option_t * opt = "")
        //      { TString o = opt; if ( o.Contains("tag") ) return fTagDirectory; return Watcher::GetDirectory(); }
        
        //virtual void Zero(Option_t *hname="pool", Option_t *binning="");  //*MENU*
        
        //virtual void Add(TTask *);

        //virtual Bool_t TestTag(Option_t *opt);   //*MENU*
        
        //virtual void Tag(Option_t *opt = ""); //*MENU*
        
        ClassDef(WatcherWithTag,0)  // To handle watchers with tagged histograms
};

class LoopControl : public WatcherWithTag
{
private:
        TH1 *fLoopTime;
private:        
        TStopwatch      fTimeControl;
        Double_t        fDelta; 
private:
        TTask *fMother;
private:
        TDirectory *fMotherDirWatcher;
        TDirectory *fMotherDirTag;
        
private:
        TTimer  *fTimer;
        TString fLastSaveArg1;
        TString fLastSaveArg2;
        TString fLastSaveArg3;
          Int_t fLastSaveArg4;
        
protected:      
        virtual void DoCanvas(TCanvas *, Option_t *);
        
public:
        LoopControl(TTask *, TDirectory *, TDirectory *);
        virtual ~LoopControl();
        
        virtual void Zero(Option_t * hname = "pool", Option_t *binning="");  //*MENU*
        

//      void Save(const Char_t *main_file = "", const Char_t *tag_file = "0", Option_t *option = "", Int_t autotime = 0); //*MENU* *ARGS={main_file=>fLastSaveArg1,tag_file=>fLastSaveArg2,option=>fLastSaveArg3,autotime=>fLastSaveArg4}
        void Save(const Char_t *main, const Char_t *tag, const Char_t *option, Int_t autotime); // *MENU* *ARGS={main=>fLastSaveArg1,tag=>fLastSaveArg2,option=>fLastSaveArg3,autotime=>fLastSaveArg4}
        
        void AutoSave();
        void SetAutoTime(Int_t autotime = 0); //*MENU* 
        const Char_t *GetLastSaveArg1() 
                { return fLastSaveArg1.Data(); }
        const Char_t *GetLastSaveArg2() 
                { return fLastSaveArg2.Data(); }
        const Char_t *GetLastSaveArg3() 
                { return fLastSaveArg3.Data(); }
        Int_t GetLastSaveArg4() 
                { return fLastSaveArg4; } 
        
        //void ShowCanvas(Option_t *option = "") ;//*MENU*
        
        virtual void Exec(Option_t *option); 
        
        ClassDef(LoopControl,0)  // to control the execution of LoopOnTasks     
};


class LoopOnTasks : public TTask 
{
private:
        Bool_t  fIsLoop;
        TTimer  *fTimer;
        
private:        
        virtual Bool_t HandleTimer(TTimer* timer);
        
private:
        LoopControl *fControl;
        
public:
        LoopOnTasks(TDirectory *dir_watchers, TDirectory *dir_tag) : 
                TTask("LoopOnTask","0"), 
                fIsLoop(false), 
                fTimer(new TTimer()), 
                fControl(new LoopControl(this,dir_watchers,dir_tag)) { Add(fControl); }
        virtual ~LoopOnTasks()
        { 
                /*  delete fControl */
                ; 
                // no need to do it, done by task destructor
        }       

        virtual void Continue() 
                {;}     
        virtual void SetBreakin(Int_t /*breakin*/ = 1) 
                {;}
        virtual void SetBreakout(Int_t /*breakout*/ = 1)
                {;}

        virtual void SetActive(Bool_t active=kTRUE); // *TOGGLE*
        
        virtual void Abort(); //*MENU*
        
        virtual void ExecuteTask(Option_t* option = "l"); // *MENU*
        
        virtual void Exec(Option_t *option); 
        
        ClassDef(LoopOnTasks,0)  // to loop on task once or infinitely
};
        
} // end namespace

#endif