TTreeWatchers.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_TTreeWatchers
#define Gw_TTreeWatchers

#include "Watchers.h"
#include "GCondition.h"

#include "TTree.h"
#include "TH1.h"
#include "TH2.h"
#include "TLeaf.h"

namespace Gw 
{

/*
 
 DoSpectra (default = 2) : 
 - 0 user spectra are not filled. Spectra under GCondition are always filled
 - 1 user spectra are filled only if the global conditions for this watcher is passed
 - 2 user spectra are always filled 
 
 DoTree (default = 2) :
 - 0 Tree is not filled 
 - 1 Tree is filled only if condition 
 - 2 Tree is filled and TEntryList is build
        
*/
class TTreeBuilder
{
protected:
    static TString gDefaultPathOfOut;
    static TString gDefaultTTreeName;
  
protected:
        // the tree to be filled by the watcher
        TTree *fMyTree; 
        // true if the tree belongs to this 
        Bool_t fIsOwner;
        
protected:
        // 0 no, 1 fill spectra only if condition is filled, 2 fill specta in any cases
        Short_t fDoSpectra;
        // 0 no, 1 fill the tree only is all conditions passed , 2 fill the tree and the TEntryList 
        Short_t fDoTree;
        
protected:
        // number of container of conditions (GCondition) on this watcher
        Short_t fNbConditions;
        
protected:
        // Should be implemented to set properly the branches in new or update mode
        virtual void SetBranches() = 0;
        virtual void FillTree();
        
public:
    TTreeBuilder(const char *name, const char *title, TTree *tree = 0x0, Short_t do_spectra = 2, Short_t do_tree = 2, Bool_t Overwrite = false);
        virtual ~TTreeBuilder();


        Short_t GetDoSpectra() const
        {
                return fDoSpectra;
        }       
        Short_t GetDoTree() const
        {
                return fDoTree;
        }       
        void SetDoSpectra(Short_t do_spectra) 
        {
                fDoSpectra = do_spectra;
        }       
        void SetDoTree(Short_t do_tree)
        {
                fDoTree = do_tree;
        }       
        
        virtual Int_t GetNbConditions() const
        {
                return fNbConditions;
        }
        
        TTree *GetTree()
                { return fMyTree; }
};      

/*
 
*/
class TTreeMaster : public Watcher, public TTreeBuilder
{
private:
        // list of Watchers filling a branch
        TList fListOfWatchers;
    
protected:
    TH1 *fErrors;

protected:
        // Should be implemented to set properly the branches in new or update mode
        virtual void SetBranches()
                {;}
        
public:
    TTreeMaster(const char *name, const char *title, Short_t do_spectra = 2, Short_t do_tree = 2, Bool_t Overwrite = false);
        virtual ~TTreeMaster();

    static void SetDefaultPathAndName(const char *new_path = "./Out",const char *treename = "TreeMaster");
        
    /*
    virtual void SetDirectory(TDirectory *mother_dir_of_watcher, TDirectory *mother_dir_for_tag, Bool_t load_objects = true)
    {
        Watcher::SetDirectory(mother_dir_of_watcher,mother_dir_for_tag,load_objects);
    }
     */
    

        virtual UInt_t Snapshot(Option_t * = "*"); //*MENU*
        
        template<typename Watcher_T> Watcher_T * Add(const Char_t *name, const Char_t *title, Short_t do_spectra, Short_t do_tree)
        {
                Watcher_T *watcher = new Watcher_T(name,title,GetTree(),do_spectra,do_tree);            
                Add( watcher );
                
                return watcher;         
        }
        template<typename Watcher_T> Watcher_T * Add(const Char_t *name, const Char_t *title)
        {
                Watcher_T *watcher = new Watcher_T(name,title,GetTree());
                Add( watcher );
                
                return watcher;
        }
        
        template<typename Watcher_T> Watcher_T * AddWatcher(const Char_t *name, const Char_t *title)
        {
                Watcher_T *watcher = new Watcher_T(name,title);
                Add( watcher );
                
                return watcher;
        }

        virtual void FillTree()
        { 
                if ( GetTree() )
                        GetTree()->Fill(); 
        }
        
        virtual void Add(TTask *);
        

        virtual void Add(Watcher *, ADF::DFTrigger *);
    
        virtual void Exec(Option_t *option="");
    
    virtual void Print(Option_t *) const;  //*MENU*

        ClassDef(TTreeMaster,0)  // Watcher that owns the tree and call Fill 
};
        
class SimpleGCondHandler1D : public GCondHandler
{
private:
        TLeaf *fData;
        
private:
        TH1 *fHisto;
        
public:
        SimpleGCondHandler1D(GCondition *cond, TLeaf *data, TH1 *h) : GCondHandler(cond), fData(data), fHisto(h)
                {;}
        virtual ~SimpleGCondHandler1D() 
                {;}                     
        
        virtual Bool_t Check();
        virtual void Fill()
        {
                for (Int_t i = 0; i < fData->GetLen(); i++) {
                        fHisto->Fill(fData->GetValue(i));
                }
        }       
};

class SimpleGCondHandler2D : public GCondHandler
{
private:
        TLeaf *fData1;
        TLeaf *fData2;
        
private:
        TH1 *fHisto;
        
public:
        SimpleGCondHandler2D(GCondition *cond, TLeaf *data1, TLeaf *data2, TH1 *h) : GCondHandler(cond), fData1(data1), fData2(data2), fHisto(h)
        {;}
        virtual ~SimpleGCondHandler2D() 
        {;}                     
        
        virtual Bool_t Check()
        {
                Bool_t is_passed = false;
                //
                for (Int_t i = 0; i < fData1->GetLen(); i++) {
                        for (Int_t j = 0; j < fData2->GetLen(); j++) {
                                if ( fCond->IsPassed(fData1->GetValue(i),fData2->GetValue(j)) )
                                        is_passed = true;
                        }
                }
                return is_passed;
        }
        virtual void Fill()
        {
                for (Int_t i = 0; i < fData1->GetLen(); i++) {
                        for (Int_t j = 0; j < fData2->GetLen(); j++) {
                                fHisto->Fill(fData1->GetValue(i),fData2->GetValue(j));
                        }
                }
        }       
};


class TTreeWithConditions : public Watcher, public TTreeBuilder 
{
protected:
        TTree *fClone;
protected:
        std::list < GCondHandler * > fCondHandler; 
protected:
        std::list < GCondition * > fUserGCond;          
protected:
        std::vector < TTreeFormula * > fUserTFCond;
protected:
        std::vector < GCondition * > fAllGCond;
    
protected:
        virtual void Clear(Option_t* = "") = 0;
protected:
        virtual void AddBranches(TTree *tree) = 0;
        virtual void FillBranches() = 0;
        
protected:
        virtual void SetBranches() 
        { 
                if ( fDoTree > 0 )
                        AddBranches(GetTree()); 
                AddBranches(fClone); 
        }
protected:
        virtual void BuildSpectraByUser() 
                {;}     
        virtual void FillSpectraByUser() 
                {;}

protected:
        virtual std::pair< GCond1D *, TH1 * > MakeGCond1D(
                                                        const Char_t *name_cond, const Char_t *title_cond, const Char_t *name_leaf, 
                                                        const Char_t *name_hist, const Char_t *title_hist , Int_t bin, Double_t min, Double_t max, 
                                                        Option_t *opt = "F",
                                                        const Char_t *sub = "");
        /*
         The leaf name should have the form X:Y otherwise it fails
         */
        virtual std::pair< GCond2D *, TH2 * > MakeGCond2D(
                                                        const Char_t *name_cond, const Char_t *title_cond, const Char_t *name_leaf,  
                                                        const Char_t *name_hist, const Char_t *title_hist, Int_t binx, Double_t xmin, Double_t xmax, Int_t biny, Double_t ymin, Double_t ymax, 
                                                        Option_t *opt = "F",
                                                        const Char_t *sub = "");                
        
        virtual GCond1D * MakeGCond1D(const Char_t *name_cond, const Char_t *title_cond);
        virtual GCond2D * MakeGCond2D(const Char_t *name_cond, const Char_t *title_cond);
        
public:
        virtual Int_t CheckCondByHandler();
        virtual Int_t CheckTreeFormula();
        
        //              virtual void FillSpectraByHandler();
        
public:
        TTreeWithConditions(const char *name, const char *title, TTree *tree = 0x0, Short_t do_spectra = 2, Short_t do_tree = 2);
        virtual ~TTreeWithConditions();
                

        virtual UInt_t Snapshot(Option_t * = "*"); //*MENU*
        
        const std::vector < GCondition * > & GetListOfGConditions() const
        {
                return fAllGCond;
        }
        /*
         const std::vector < TTreeFormula * > & GetListOfFormula() const
         {
         return fUserTFCond;
         }      
         */
        // 
        virtual void SetDirectory(TDirectory *mother_dir_of_watcher, TDirectory *mother_dir_tag = 0x0, Bool_t load_objects = true);
        
    virtual Int_t AddTreeFormula(const Char_t *, const Char_t *); //*MENU*
        
        virtual Int_t CheckCond()
        {
                return CheckCondByHandler();
        }
        
        virtual void FillSpectra()
        {
                // spectra declared with conditions are automatically filled 
                FillSpectraByUser();
        }
        
        virtual void Exec(Option_t *option="");
        
        ClassDef(TTreeWithConditions,0)  // Watcher that owns the tree and call Fill 
};

        
} // namespace

#endif