TTreeWatchers.cpp

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.             *
 ***************************************************************************/

#include "TTreeWatchers.h"

#include "TTreeFormula.h"
#include "TRegexp.h"
#include "TSystem.h"
#include "TSystemDirectory.h"
#include "TDirectory.h"
#include "TKey.h"

using namespace Gw;

TString TTreeBuilder::gDefaultPathOfOut = "./Out";
TString TTreeBuilder::gDefaultTTreeName = "TreeMaster";

TTreeBuilder::TTreeBuilder(const char *name, const char *title, TTree *tree, Short_t do_spectra, Short_t do_tree, Bool_t Overwrite) :
        fMyTree(tree),
        fIsOwner(true),
        fDoSpectra(do_spectra),
        fDoTree(do_tree),
        fNbConditions(0)
{
        // no need 
        if ( fMyTree ) 
                fIsOwner = false;
        else {

                fIsOwner = true;
                
                // keep the current directory
                TDirectory *cdir = gDirectory;
                
                // open a TFile with a TTree using the name and title of the watcher
                // check if a tree already exists, otherwise creates it 
                TString tmp = Form("%s/%s_w0.root",gDefaultPathOfOut.Data(),name);

        TFile *rootfile = 0x0;

        if(Overwrite == false)
        {
                // Check if such a file exist in the current directory
                TSystemDirectory dir; dir.SetDirectory(gDefaultPathOfOut.Data()); TList *list = dir.GetListOfFiles();
                if ( list ) {
                        // loop to find the first free file with the format name_w%d.root
                        int cycle;
                        for ( int i = 0; i <= 1000000; i++ ) { // up to MAXCYCLE files
                                
                                tmp.Form("%s_w%d.root",name,i);         
                                cycle = i;
                                if ( !list->FindObject(tmp.Data()) ) 
                                        { break; }
                        } 
            tmp.Form("%s/%s_w%d.root",gDefaultPathOfOut.Data(),name,cycle);
                        delete list;
                }

        rootfile = new TFile(tmp.Data(),"NEW");
        }
        else
            rootfile = new TFile(tmp.Data(),"RECREATE");

                std::cout << " Root file opened by TreeBuilder " << tmp.Data() << std::endl;  
                
        if ( rootfile )
            rootfile->cd();
                fMyTree = new TTree(gDefaultTTreeName.Data(),title);
                
                // back to the current directory
                if ( cdir )
                        cdir->cd();                     
        }
}

void TTreeBuilder::FillTree()
{
        if ( fIsOwner )
                fMyTree->Fill();
}

TTreeBuilder::~TTreeBuilder()
{
    if ( fIsOwner ) {

        // keep the current directory
        TDirectory *cdir = gDirectory;

        // to get the current root file and save the ttree
        TFile *rfile = fMyTree->GetCurrentFile();
        rfile->cd();

//        fMyTree->Write();
        rfile->Close();

        // back to the current directory
        cdir->cd();
    }
}

//ClassImp(/*TTreeMaster*/);

TTreeMaster::TTreeMaster(const char *name, const char *title, Short_t do_spectra, Short_t do_tree, Bool_t Overwrite) :
        Watcher(name,title), 
    TTreeBuilder(name, title, 0x0,do_spectra,do_tree,Overwrite),
        fListOfWatchers(),
    fErrors(0x0)
{
        // the watchers are not delete by this !
        fListOfWatchers.SetOwner(false);
    
    // 
    fErrors = MakeTH1 <TH1F>("Errors","Errors in the different watchers filling the branches",0,0,0);
}

TTreeMaster::~TTreeMaster()
{
}

void TTreeMaster::SetDefaultPathAndName(const char *new_path, const char *treename)
{
    gDefaultPathOfOut = new_path;
    gDefaultTTreeName = treename;
}

UInt_t TTreeMaster::Snapshot(Option_t *opt)
{
        UInt_t bytes = 0u;
        
        // for all watchers, ask to snap spectra and conditions 
        TIter loopontask(GetListOfTasks());
        TObject *task;
        while ( ((task=loopontask())) ) {
                Watcher *watcher = 
                        dynamic_cast<Watcher *>(task);
                if ( watcher ) {
                        // to be sure and so that it should not be necessary in watchers
                        bytes += watcher->Snapshot(opt);        
                }
        }
        // add additional snap which is just a Write of the tree        

        return bytes;
}

void TTreeMaster::Add(TTask *task)
{
        if ( task == 0x0 || fTrigger == 0x0 )
                return;
        if ( fTrigger->IsZombie() )
                return;
        
        Watcher *watcher =
        dynamic_cast<Watcher *>(task);
        if ( watcher )
                Add(watcher,fTrigger);
}

void TTreeMaster::Add(Watcher *watch, ADF::DFTrigger *trig)
{
        if ( watch == 0x0 || trig == 0x0 )
                return;
        if ( trig->IsZombie() )
                return;
        
        // Add a new watcher, associates the trigger, add to the list of watchers, set the directory and allocate histograms
        TFolder *topfolder =
        (TFolder *)gROOT->GetRootFolder()->FindObject("//root/GwWatchers");
        TFolder *w_folder = (TFolder *)gROOT->GetRootFolder()->FindObjectAny( Form("//root/GwWatchers/%s", watch->GetName() ) );
        if ( w_folder ) { // shoud aways be true ...
                topfolder->Remove(w_folder);
                fTopFolder->Add(w_folder);
        }
        
        if ( fDirectory ) {
                Bool_t ok_dir = false;
                if ( fTagDirectory ) {
                        ok_dir = MakeDir(fTopFolder, fDirectory, true);
                        if ( fTagDirectory != fDirectory ) {
                                ok_dir = ok_dir && MakeDir(fTopFolder, fTagDirectory, true);
                        }
                }
                if (ok_dir) {
            TDirectory *d1 = fDirectory->GetDirectory(fTopFolder->GetName());
            TDirectory *d2 = fTagDirectory->GetDirectory(fTopFolder->GetName());
            
                        watch->SetDirectory(d1,d2,true);
                }
        }
    
    // to set errors in main loop
    fErrors->SetBins(fErrors->GetNbinsX()+1,fErrors->GetXaxis()->GetXmin(),fErrors->GetXaxis()->GetXmax()+1.0);
    fErrors->GetXaxis()->SetBinLabel(fErrors->GetXaxis()->GetNbins()-1,watch->GetName());

        watch->SetTrigger(trig);
        TTask::Add(watch);
    fListOfWatchers.Add(watch);
}

void TTreeMaster::Exec(Option_t * option)
{
        Short_t do_spectra_token = 2, nb_ok_tree = 0u, nb_watcher_tree = 0u; Int_t pass, current = 0;
    Bool_t do_tree = true;
        
        TTask *task; TObjLink *lnk = GetListOfTasks()->FirstLink();
        while (lnk) {
        
        current++;
        
                task = (TTask *)lnk->GetObject();
                if ( !task->IsActive() ) {
                        // active should set tree and  
                        lnk = lnk->Next();
                        continue;       
                }
                Watcher *watcher = 
                        dynamic_cast<Watcher *>(task); 
                TTreeBuilder *t_builder = 
                        dynamic_cast<TTreeBuilder *>(task);
                
                if ( t_builder ) {
            nb_watcher_tree++;

                        switch (fDoSpectra ) {
                                case 0:
                                        t_builder->SetDoSpectra(0);
                                        break;
                                case 1:
                                        t_builder->SetDoSpectra(do_spectra_token);
                                        break;                                          
                                case 2:
                                default:
                                        t_builder->SetDoSpectra(2);                             
                                        break;                          
                        }               
                }
                // to be sure and so that it should not be necessary in watchers
                watcher->SetLastExecStatus(0);
                // execute
                watcher->Exec(option);
                //check the status to know if the tree should be filled                 
                pass = watcher->GetLastExecStatus();
                
        if ( t_builder ) {
            if ( pass < 0 ) {
                // count number of errors
                do_tree = false;
                fErrors->SetBinContent( current + 1, fErrors->GetBinContent(current+1) + 1 );
                
                break;
            }
            else {
                // to deal with spectra
                nb_ok_tree++;

                switch ( fDoSpectra ) {
                    case 0:
                        break;
                    case 1:
                        if ( t_builder->GetNbConditions() == pass ) {
                            do_spectra_token = 1;
                        }
                        else 
                            do_spectra_token = 0;
                        break;                                          
                    case 2:
                        break;
                }
            }
        } // t_builder
                
                lnk = lnk->Next();
                
                if ( !gROOT->IsBatch() ) {
                        gSystem->DispatchOneEvent(true);
                        gSystem->ProcessEvents();
                }
        }
    
    // fill only if all watchers processed without errors
    if ( do_tree  ) {
        switch (fDoTree) {
            case 0:
                break;
            case 1:
                if ( nb_ok_tree == nb_watcher_tree )
                    FillTree();
                break;
            default:
                FillTree();
                break;
        }
    }
}

void TTreeMaster::Print(Option_t */*option*/) const
{
    std::cout<<std::endl;
    int size = 3 + 3 + ((TString)GetName()).Length() + 5 + ((TString)GetTitle()).Length() + 3 + 3;
    for(int i=0; i<size ; i++) std::cout<<"*";
    std::cout<<std::endl;
    std::cout<<"***   "<<GetName()<<" --- "<<GetTitle()<<"   ***"<<std::endl;
    for(int i=0; i<size ; i++) std::cout<<"*";
    std::cout<<std::endl;

    std::cout<<"TFile : "<<fMyTree->GetCurrentFile()->GetName()<<std::endl;
    std::cout<<"TTree : "<<fMyTree->GetName()<<" ; "<<fMyTree->GetTitle()<<std::endl;
    fMyTree->Print();
    std::cout<<"    List of GW Watchers filling this tree:"<<std::endl;
    for(int i=0 ; i<fListOfWatchers.GetSize() ; i++)
    {
        std::cout<<"        --−> "<<((Watcher*)fListOfWatchers.At(i))->GetName()<<std::endl;
    }
    std::cout<<"    List of branches in the tree:"<<std::endl;
    for(int i=0 ; i<fMyTree->GetListOfBranches()->GetEntries() ; i++)
    {
        std::cout<<"        --−> "<<((TList*)fMyTree->GetListOfBranches())->At(i)->GetName()<<std::endl;
    }

    std::cout<<"Number of written entries : "<<fMyTree->GetEntries()<<std::endl;

    if ( fIsOwner )
    {
        // keep the current directory
        TDirectory *cdir = gDirectory;
        // to get the current root file and save the ttree
        TFile *rfile = fMyTree->GetCurrentFile();
        rfile->cd();
        fMyTree->Write();
        // back to the current directory
        cdir->cd();
    }

    std::cout<<std::endl;
}


Bool_t SimpleGCondHandler1D::Check()
{
    Bool_t is_passed = false;
    //
    for (Int_t i = 0; i < fData->GetLen(); i++) {
        Double_t val = fData->GetValue(i);
        
        if ( fCond->IsPassed( val ) )
        {
            is_passed = true;
            break;
        }
    }
    return is_passed;
}

//ClassImp(TTreeWithConditions);

TTreeWithConditions::TTreeWithConditions(const char *name, const char *title, TTree *tree, Short_t do_spectra, Short_t do_tree) : 
        Watcher(name,title), 
        TTreeBuilder(name,title,tree,do_spectra,do_tree),
        fClone(0x0),
        fCondHandler(),
        fUserGCond(),
        fUserTFCond(),
        fAllGCond()
{
        // clone is always set since it is used for coincidences.
        fClone = new TTree(Form("WC_%s_",name),Form("Clone of %s %s",name,title));
        if ( fClone ) {
                fClone->SetDirectory(0);
                fClone->SetCircular(1);
        }
}
TTreeWithConditions::~TTreeWithConditions()
{
        //
        if ( fClone ) {
                delete fClone; fClone = 0x0;
        }
        // delete all conditions 
        std::vector< GCondition * >::iterator 
        listed_item; 
        for ( listed_item = fAllGCond.begin() ; listed_item != fAllGCond.end() ; listed_item++ ) {
                if ( (*listed_item) ) {
                        delete (*listed_item);
                        (*listed_item) = 0x0;   
                }
        }
}

UInt_t TTreeWithConditions::Snapshot(Option_t *opt)
{
        TString o = opt; Bool_t save_cond = true; UInt_t bytes = 0u; TDirectory *in_dir = gDirectory;
    
        if ( o.Contains("!cond")) {
                // means do not save conditions
                save_cond = false; o.ReplaceAll("!cond","");
        }
        // save spectra
        bytes += Watcher::Snapshot(o.Data());
        
        if ( save_cond && fDirectory ) {
            
        TDirectory *dir_w = fDirectory->GetDirectory(Form("%s",GetName()));
        TDirectory *dir_cuts = fDirectory->GetDirectory(Form("%s/ListOfGCuts",GetName()));;
        if ( dir_cuts ) {
            dir_cuts->cd();
        }
        
        Bool_t wildcard = false;
        if ( o.Contains("*") )
            wildcard = true;
                TRegexp rexp(Form("%s",o.Data()),wildcard);
       
                if ( rexp.Status() == TRegexp::kOK ) {
                        // check first it is not already there ?
                        std::vector< GCondition * >::iterator 
                                listed_item; 
                        for ( listed_item = fAllGCond.begin() ; listed_item != fAllGCond.end() ; listed_item++ ) {
                                o = (*listed_item)->GetName();
                                if ( o.Contains(rexp) ) {                    
                    if ( dir_w )
                        bytes += dir_w->WriteTObject((*listed_item));

                    if ( dir_cuts ) {
                        const TObjArray *list_of_individual_cuts = &((*listed_item)->GetListOfConditions());
                        
                        for (Int_t i = 0; i < list_of_individual_cuts->GetSize(); i++) {
                            if ( list_of_individual_cuts->At(i) )
                                bytes += dir_cuts->WriteTObject(list_of_individual_cuts->At(i));
                        }
                    }
                                }
                        }       
                }
        if ( in_dir )
            in_dir->cd();
        else
            gDirectory = 0x0;
        }
        
        return bytes;
}

std::pair< GCond1D *, TH1 * > TTreeWithConditions::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,
                                                const Char_t * sub)
{       
        TString tmp = opt; std::pair < GCond1D *, TH1 * > p; GCondHandler *handler = 0x0; GCond1D *cond = 0x0; TH1 *hist = 0x0;
        p.first  = 0x0;
        p.second = 0x0;
        
        // check first it is not already there ?
        std::vector< GCondition * >::iterator 
        listed_item; 
        for ( listed_item = fAllGCond.begin() ; listed_item != fAllGCond.end() ; listed_item++ ) {
                tmp = (*listed_item)->GetName();
                if ( tmp == name_cond ) {
                        std::cout << "Cannot have two conditions wth the same name " << name_cond << std::endl;
                        return p;       
                }
        }
        
        //  find leaf in the tree
        TLeaf *leaf = fClone->GetLeaf(name_leaf); 
        if ( leaf == 0x0 ) {
                // log to be added
                
                return p;
        }
        
        // Associated histogram
        tmp = opt;
        
        if ( tmp.Contains("C") ) 
        {
                hist = MakeTH1<TH1C>(name_hist,title_hist,bin,min,max,sub) ;
        }
        else if ( tmp.Contains("S") )
        {
                hist = MakeTH1<TH1S>(name_hist,title_hist,bin,min,max,sub);             
        }
        else if ( tmp.Contains("I") )
        {
                hist = MakeTH1<TH1I>(name_hist,title_hist,bin,min,max,sub);                             
        }
        else if ( tmp.Contains("F") )
        {
                hist = MakeTH1<TH1F>(name_hist,title_hist,bin,min,max,sub);                                             
        }
        else if ( tmp.Contains("D") )
        {
                hist = MakeTH1<TH1D>(name_hist,title_hist,bin,min,max,sub);                                                             
        }       
        else if ( tmp.Contains("P") )
        {
                //              hist = new TProfile(name_hist,title_hist,bin,min,max);                                                                          
        }       
        
        cond = new GCond1D(name_cond,title_cond);
        if ( cond == 0x0 || hist == 0x0) {
                if ( cond ) {
                        delete cond;
                }
                if ( hist ) {
                        delete hist;
                }
                return p;
        }
        else {          
                cond->SetVarName(name_leaf,"X");
        if ( fTopFolder ) {
            if ( fTopFolder->FindObject("ListOfGCuts") == 0x0 )
                fTopFolder->AddFolder("ListOfGCuts","To keep list of possible GCuts for that watchers");
            fTopFolder->Add(cond);
        }

                handler = new SimpleGCondHandler1D( cond, leaf, hist );
                fCondHandler.push_back(handler);
                
                fNbConditions++;
                fAllGCond.push_back(cond);
        }
        
        p.first  = cond; p.second = hist; return p;
}

std::pair< GCond2D *, TH2 * > TTreeWithConditions::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,
                const Char_t *sub)
{       
        TString tmp = opt, tmp_leaf(name_leaf); std::pair < GCond2D *, TH2 * > p; GCond2D *cond = 0x0; GCondHandler *handler = 0x0; TH2 *hist = 0x0;
        //
        p.first  = 0x0;
        p.second = 0x0;
        
        // check first it is not already there ?
        std::vector< GCondition * >::iterator 
                listed_item; 
        for ( listed_item = fAllGCond.begin() ; listed_item != fAllGCond.end() ; listed_item++ ) {
                tmp = (*listed_item)->GetName();
                if ( tmp == name_cond ) {
                        std::cout << "Cannot have two conditions wth the same name " << name_cond << std::endl;
                        return p;       
                }
        }
        
        TObjArray *name_leaves = tmp_leaf.Tokenize(":");
        if ( name_leaves == 0x0 || name_leaves->GetEntries() != 2 ) {
                // log to be added
                printf("Cannot get leafes from %s \n",name_leaf);
                return p;
        }
        
        //  find leaf in the tree
        TLeaf *leaf1 = fClone->GetLeaf( name_leaves->At(0)->GetName() ), *leaf2 = fClone->GetLeaf( name_leaves->At(1)->GetName() ); 
        delete name_leaves;
        
        if ( leaf1 == 0x0 || leaf2 == 0x0 ) {
                // log to be added
                printf("Cannot find leafes \n");
                
                return p;
        }
        
        // Associated histogram
        tmp = opt;
        
        if ( tmp.Contains("C") ) 
        {
                hist = MakeTH2<TH2C>(name_hist,title_hist,binx,xmin,xmax,biny,ymin,ymax,sub);
        }
        else if ( tmp.Contains("S") )
        {
                hist = MakeTH2<TH2S>(name_hist,title_hist,binx,xmin,xmax,biny,ymin,ymax,sub);           
        }
        else if ( tmp.Contains("I") )
        {
                hist = MakeTH2<TH2I>(name_hist,title_hist,binx,xmin,xmax,biny,ymin,ymax,sub);                           
        }
        else if ( tmp.Contains("F") )
        {
                hist = MakeTH2<TH2F>(name_hist,title_hist,binx,xmin,xmax,biny,ymin,ymax,sub);                                           
        }
        else if ( tmp.Contains("D") )
        {
                hist = MakeTH2<TH2D>(name_hist,title_hist,binx,xmin,xmax,biny,ymin,ymax,sub);                                                           
        }       
        else if ( tmp.Contains("P") )
        {
                //              hist = new TProfile(name_hist,title_hist,bin,min,max);                                                                          
        }       
        
        cond = new GCond2D(name_cond,title_cond);
        if ( cond == 0x0 || hist == 0x0 ) {
                if ( cond ) {
                        delete cond;
                }
                if ( hist ) {
                        delete hist;
                }
                return p;
        }
        else { 
                cond->SetVarName(leaf1->GetName(),"X"); cond->SetVarName(leaf2->GetName(),"Y");
                
        if ( fTopFolder ) {
            if ( fTopFolder->FindObject("ListOfGCuts") == 0x0 )
                fTopFolder->AddFolder("ListOfGCuts","To keep list of possible GCuts for that watchers");
            fTopFolder->Add(cond);
        }
                
                //
                handler = new SimpleGCondHandler2D( cond, leaf1, leaf2, hist );
                //
                fCondHandler.push_back(handler);
                
                fNbConditions++;
                fAllGCond.push_back(cond);
        }
        
        p.first  = cond; p.second = hist; return p;
}

GCond1D * TTreeWithConditions::MakeGCond1D(const Char_t *name_cond, const Char_t *title_cond)
{
        GCond1D *cond = 0x0; 
        
        // check first it is not already there ?
        std::vector< GCondition * >::iterator 
                listed_item; 
        for ( listed_item = fAllGCond.begin() ; listed_item != fAllGCond.end() ; listed_item++ ) {
                TString tmp = (*listed_item)->GetName();
                if ( tmp == name_cond ) {
                        std::cout << "Cannot have two conditions wth the same name " << name_cond << std::endl;
                        return cond;    
                }
        }
        cond = new GCond1D(name_cond,title_cond);
        if ( cond ) {
                fUserGCond.push_back(cond); fAllGCond.push_back(cond); 
        }
        
        return cond;    
}

GCond2D * TTreeWithConditions::MakeGCond2D(const Char_t *name_cond, const Char_t *title_cond)
{
        GCond2D *cond = 0x0;
        
        // check first it is not already there ?
        std::vector< GCondition * >::iterator 
        listed_item; 
        for ( listed_item = fAllGCond.begin() ; listed_item != fAllGCond.end() ; listed_item++ ) {
                TString tmp = (*listed_item)->GetName();
                if ( tmp == name_cond ) {
                        std::cout << "Cannot have two conditions wth the same name " << name_cond << std::endl;
                        return cond;    
                }
        }
        cond = new GCond2D(name_cond,title_cond);
        if ( cond ) {
                fUserGCond.push_back(cond); fAllGCond.push_back(cond); 
        }
        
        return cond;    
}


void TTreeWithConditions::SetDirectory(TDirectory *mother_dir_of_watcher, TDirectory *mother_dir_tag, Bool_t load_objects)
{
    TDirectory *new_cond_dir;

        // apply modifications of the directtory first for spectra & tagged spectra
        Watcher::SetDirectory(mother_dir_of_watcher,mother_dir_tag,load_objects);
    if ( GetDirectory() == 0x0 )
        return;
    
        // add also conditions to the watcher diectory  
        new_cond_dir = GetDirectory()->GetDirectory(Form("%s/ListOfGCuts",GetName()));
        if ( new_cond_dir == 0x0 )
                new_cond_dir = GetDirectory()->mkdir(Form("%s/ListOfGCuts",GetName()));
    //
    if (new_cond_dir == 0x0 || load_objects == false ) {
        return;
    }    
    // load object from the destination directory 
        std::vector< GCondition * >::iterator
        listed_item;
        for ( listed_item = fAllGCond.begin() ; listed_item != fAllGCond.end() ; listed_item++ ) {
        LoadObject((*listed_item), GetDirectory());
        }

    // load all predfined cuts in ListOfGcuts
    TFolder *folder =
        (TFolder *)fTopFolder->FindObject("ListOfGCuts");
    
        TIter it(new_cond_dir->GetListOfKeys()); TKey *key_in_file;
        // start
        while ( (key_in_file = static_cast<TKey *>(it())) ) { // next key
        
        TString class_name = key_in_file->GetClassName(); // TString objet_name = key_in_file->GetName();
        
                if ( class_name.EqualTo("Gw::Peak1D") || class_name.EqualTo("TCutG") ) {
            
            if ( !folder->FindObject(key_in_file->GetName()) ) { // not yet in the collection, add highest cycle
                TKey *last_key_for_that_object =
                    new_cond_dir->FindKey(key_in_file->GetName());
                
                TObject *obj = last_key_for_that_object->ReadObj();
                folder->Add( obj );
                gROOT->GetListOfSpecials()->Remove( obj ); 
            }
        }
        }
}

Int_t TTreeWithConditions::CheckCondByHandler()
{
        Int_t nb = 0;
        
        std::list< GCondHandler * >::iterator 
                listed_item; 
        for ( listed_item = fCondHandler.begin() ; listed_item != fCondHandler.end() ; listed_item++ ) {
                (*listed_item)->Fill();
                if ( (*listed_item)->Check() )
                        nb++;
        }
        /*
         std::vector< TTreeFormula * >::iterator 
         listed_formula; 
         for ( listed_formula = fUserTFCond.begin() ; listed_formula != fUserTFCond.end() ; listed_formula++ ) {
         if ( (*listed_formula)->EvalInstance() )
         nb++;
         }
         */
        
        return nb;
}

Int_t TTreeWithConditions::CheckTreeFormula()
{
        Int_t nb = 0;
        
        std::vector< TTreeFormula * >::iterator 
        listed_formula; 
        for ( listed_formula = fUserTFCond.begin() ; listed_formula != fUserTFCond.end() ; listed_formula++ ) {
                if ( (*listed_formula)->EvalInstance() )
                        nb++;
        }
        
        return nb;
}

/*
 void  TTreeWithConditions::FillSpectraByHandler()
 {
 std::list< GCondHandler * >::iterator 
 listed_item; 
 for ( listed_item = fCondHandler.begin() ; listed_item != fCondHandler.end() ; listed_item++ ) {
 (*listed_item)->Fill();
 }      
 }
 */

Int_t TTreeWithConditions::AddTreeFormula(const Char_t */*name*/, const Char_t */*expression*/)
{
        /*
        TTreeFormula *nf = new TTreeFormula(name,expression,fClone);
        
        if ( nf->GetTree() ) { // test if it is a good expression ... should log
                fUserTFCond.push_back(nf);
        }
        
        return fUserTFCond.size();
         */
        return 0;
}

void TTreeWithConditions::Exec(Option_t * /*option*/) 
{       
        // Clear everything
        Clear();
        // fill the event using FillBranches method and set the entry in the clone which is circular with on entry
        FillBranches(); 
        
        // check conditions
        fClone->Fill(); 
        Short_t nb_cond = CheckCond() ; SetLastExecStatus(nb_cond);

        switch ( fDoSpectra ) {
                case 0:
                        break;
                case 1:
                        if ( nb_cond == GetNbConditions() )
                                FillSpectra();                  
                        break;  
                case 2:
                default:
                        FillSpectra();
                        break;
        }
}