Watchers.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2011 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
#include "Watchers.h"
#endif

// root includes
#ifndef ROOT_TROOT
#include "TROOT.h"
#endif
#ifndef ROOT_TSystem
#include "TSystem.h"
#endif
#ifndef ROOT_TBrowser
#include "TBrowser.h"
#endif
#ifndef ROOT_TRegexp
#include "TRegexp.h"
#endif
#include "TKey.h"
#include "TClass.h"

#include "TStyle.h"
#include "TThread.h"

using namespace Gw;
using namespace ADF;

ClassImp(Watcher);

// default is histograms of the pool not deleted
Bool_t Watcher::fgDeletePool = false;
// list of all allocate watchers
TList *Watcher::fgListOfWatchers = 0x0;

void Watcher::Register(Watcher *w, Option_t *opt)
{
        // just in case. In principle init should not be run in independant thread
        TThread::Lock();

        TString option = opt;
        
        // check if list exist
        if ( fgListOfWatchers == 0x0 ) {

                fgListOfWatchers = new TList();
                fgListOfWatchers->SetOwner(false);      
        }
        
        if ( option == "-" ) {
                fgListOfWatchers->Remove(w);
                
                if ( fgListOfWatchers->GetSize() == 0 ) { // no more watcher ==> delete the global list
                        delete fgListOfWatchers;
                        fgListOfWatchers = 0x0;
                }
        }
        else {
                fgListOfWatchers->Add(w);
        }
        // just in case. In principle init should not be run in independant thread      
        TThread::UnLock();
}

Watcher *Watcher::GetLastRegistered(const Char_t *classname, Option_t *opt /*, const Char_t *kind */)
{
        Watcher *result_w = 0x0; TString option = opt; 
        
        if ( fgListOfWatchers == 0x0 ) {
                return result_w;
        }
        TIter next(fgListOfWatchers,kIterBackward);
        TObject *obj;
        while ( (obj = next()) ) {
                if ( option == "baseclass" &&  obj->InheritsFrom(classname) ) {
                        result_w = dynamic_cast<Watcher *> (obj);
/*                      if ( ! result->IsKind(kind)) {
                                result = 0x0;
                                continue;
                        } */
                        break;
                }
                if ( option == "class" ) {
                        TString tmp = obj->IsA()->GetName();
                        if ( tmp == classname ) {
                                result_w = dynamic_cast<Watcher *> (obj);
/*                              if ( ! result->IsKind(kind)) {
                                        result = 0x0;
                                        continue;
                                } */
                                break;
                        }
                }
        }
        return result_w;
}

void Watcher::SetFirst(Watcher *w)
{
        fgListOfWatchers->Remove(w);
        fgListOfWatchers->AddFirst(w);
}


Watcher::Watcher() : 
        TTask(),
        fLog("Watcher"),
        fDeletePool(fgDeletePool),
        fPoolOfObjects(), 
        fTagged(),
        fReference(),
        fDirectory(0x0),
        fTagDirectory(0x0),
        fTopFolder(0x0),
//      fTopTaggedFolder(0x0),
        fLastExecStatus(0),
        fTrigger(0x0)
//      fKind("SpectraBuilder")
{
    TFolder *topfolder;

        // Also add a top folder visible from ROOT browser
        if ( gROOT->GetRootFolder()->FindObject("//root/GwWatchers") == 0x0 ) {
                gROOT->GetRootFolder()->AddFolder("GwWatchers","Folder containing all the objects created by all watchers");
    }

        topfolder =
                (TFolder *)gROOT->GetRootFolder()->FindObject("//root/GwWatchers");
        fTopFolder = topfolder->AddFolder("Watcher","Default Watcher");
        /*
        TFolder *topfolder = 
                (TFolder *)gROOT->GetRootFolder()->FindObject("//root/GwWatchers");
        fTopFolder = topfolder->AddFolder("Watcher","Default Watcher");
         */
        
        fPoolOfObjects.SetOwner(fDeletePool); 

        // add it to the list of watchers
        Register(this,"+");
}

Watcher::Watcher(const char *name, const char *title, TDirectory *mother_watcher_dir, TDirectory *mother_tag_watcher_dir) : 
        TTask(name,title), 
        fLog(name),
        fDeletePool(fgDeletePool),
        fPoolOfObjects(), 
        fTagged(),
        fReference(),
        fDirectory(0x0),
        fTagDirectory(0x0),
        fTopFolder(0x0),
//      fTopTaggedFolder(0x0),
        fLastExecStatus(0),
        fTrigger(0x0)
{
    TFolder *topfolder;
    
        // Also add a top folder visible from ROOT browser
        if ( gROOT->GetRootFolder()->FindObject("//root/GwWatchers") == 0x0 ) {
                gROOT->GetRootFolder()->AddFolder("GwWatchers","Folder containing all the objects created by all watchers");
    }

        topfolder =
                (TFolder *)gROOT->GetRootFolder()->FindObject("//root/GwWatchers");
        fTopFolder = topfolder->AddFolder(name,title);
        
        fPoolOfObjects.SetOwner(fDeletePool);   
        
        // add it to the list of watchers
        Register(this,"+");
        
        SetDirectory(mother_watcher_dir, mother_tag_watcher_dir,false); // objects not created any more, nothing to be loaded
}

Watcher::~Watcher() 
{ 
        if (fDeletePool) 
                fPoolOfObjects.SetOwner(kTRUE); 
        
        // remove it from the list of watchers
        Register(this,"-");
}

TFolder *Watcher::GetSubFolder(TFolder *topfolder, const Char_t *sub)
{
        TString subfolder = sub; TFolder *result = topfolder, *current = topfolder;
        
        if ( subfolder != "" ) { // means sub folder 
                TObjArray *tmp = subfolder.Tokenize("/"); 
                for (Int_t i = 0; i < tmp->GetEntries(); i++) {
                        if ( current->FindObject(tmp->At(i)->GetName()) == 0x0 ) { // does not exist, create it
                                current->AddFolder(tmp->At(i)->GetName(), Form("%s of %s",tmp->At(i)->GetName(),GetName()) );
                        }
                        result = current = (TFolder *)current->FindObject(tmp->At(i)->GetName());
                }
                delete tmp;
        }
        return result;  
        
        /*
        TString subfolder = sub; TDirectory *result = fDirectory, *current = fDirectory;
        
        if ( subfolder != "" && current ) { // means a subdir of fDirectory
                TObjArray *tmp = subfolder.Tokenize("/"); 
                for (Int_t i = 0; i < tmp->GetEntries(); i++) {
                        
                        if ( current == 0x0 ) {
                                result = 0x0;
                                break;
                        }
                        if ( current->GetDirectory(tmp->At(i)->GetName()) == 0x0 ) { // does not exist, create it
                                current->mkdir(tmp->At(i)->GetName());
                        }
                        result = current = current->GetDirectory(tmp->At(i)->GetName());
                }
                
                delete tmp;
        }
        return result;
         */
}

void Watcher::Add(TTask *task)
{       
        // everything is defined for that trigger 
        // if ( task == 0x0 || fTrigger == 0x0 )
        if ( task == 0x0 )
                return;
        if ( fTrigger && fTrigger->IsZombie() )
                return;
        
        // add only watcher with a correct trigger 
        Watcher *watcher = 
                dynamic_cast<Watcher *>(task);
        if ( watcher ) {
                TTask::Add(watcher);
                // Watcher defined without trigger so use this one 
                if ( watcher->GetTrigger() == 0x0 )
                        watcher->SetTrigger(fTrigger);
                
//              TDirectory *mother_dir, *mother_tag_dir;
                if ( fDirectory ) {
                        watcher->SetDirectory(fDirectory,fTagDirectory);
                }
        }
}


Bool_t Watcher::GetPathOf(TFolder *f, TObject *searched, TString &path)
{
        TObject *obj;
        //
        TIter next(f->GetListOfFolders());
        while ( (obj=next()) ) {
                
                if ( searched == obj )
                        return true;
                
                if ( obj->InheritsFrom("TFolder") ) { 
                        if ( GetPathOf((TFolder*)obj,searched,path) ) {
                                path.Prepend( Form("%s/",obj->GetName()) );
                                return true;
                        }
                }
        }
        return false;
}
 

Bool_t Watcher::MakeDir(TFolder *f, TDirectory *mother_dir, Bool_t do_top)
{
        TObject *obj; TFolder *folder; TDirectory *current, *top_dir = 0x0, *tmp_dir = 0x0;
        
        if ( mother_dir == 0x0 || f == 0x0 )
                return false;
        
//      if ( mother_dir == gROOT ) 
//              printf("-->RINT \n");
        
        // in the given directory a top directory is created corresponding to f 
        if ( do_top ) {
                top_dir = mother_dir->GetDirectory(f->GetName());
                if ( top_dir == 0x0 ) {
// Strange behavior, error printed by root by directory created                 
//                      printf("TOTO1 %s %s \n",f->GetName(),mother_dir->GetName());
//                      mother_dir->ls();
                        
                        tmp_dir = mother_dir->mkdir(f->GetName(),f->GetTitle());
                        if ( tmp_dir == 0x0 )
                                return false;
//                      printf("CREATED %s %s \n",f->GetName(),mother_dir->GetName());

                }
                else tmp_dir = top_dir;
                
                current = tmp_dir;
        }
        else current = mother_dir;
        
        TIter next(f->GetListOfFolders());
        while ( (obj=next()) ) {
                //
                if ( !obj->InheritsFrom("TFolder") ) // not only folder in this list !
                        continue;

                //
                folder = (TFolder *)obj; tmp_dir = current->GetDirectory(folder->GetName());
                if ( tmp_dir == 0x0 ) {
                        tmp_dir = current->mkdir(folder->GetName(),folder->GetTitle());
                        if ( tmp_dir == 0x0 )
                                return false;
                }
                // call recursively
                if ( !MakeDir(folder,tmp_dir,false) )
                        return false;           
        }
        
        return true;
}


void Watcher::DirToDir(TDirectory *from, TDirectory *to, TObjArray &thelist, Bool_t load_objects)
{
        if ( from == to )
                return; // nothing to be moved
        
        TObject *obj; TIter next(&thelist);

        while ( (obj = next()) ) {
                ROOT::DirAutoAdd_t func = obj->IsA()->GetDirectoryAutoAdd();
                // remove objects from the directory they belong to
                if ( from ) {
                        if ( func )
                                func(obj,0x0);          
                        else
                                from->Remove(obj);                              
                }
                // add them to the destination dir
                if ( to ) {
                        if ( load_objects )
                                LoadObject(obj, to); // takes care of loading objects from file if they exist and to set to
                        else {
                                if ( func )
                                        func(obj,to);
                                else 
                                        to->Append(obj);  
                        }
                }
        }       
}


void  Watcher::RemoveFromDir(TObject *obj, TDirectory *from)
{
        if ( from ) {
                ROOT::DirAutoAdd_t func = obj->IsA()->GetDirectoryAutoAdd();
                // remove objects from the directory they belong to
                if ( func )
                        func(obj,0x0);          
                else
                        from->Remove(obj);                              
        }       
}

void  Watcher::AddToDir(TObject *obj, TDirectory *to)
{
        if ( to ) {
                if ( ! to->TDirectory::FindObject(obj) ) {
                        ROOT::DirAutoAdd_t func = obj->IsA()->GetDirectoryAutoAdd();
                        if ( func )
                                func(obj,to);           
                        else
                                to->Append(obj);
                }
        }       
}

void Watcher::LoadObject(TObject *new_obj, TDirectory *root_dir)
{       
        TDirectory *obj_dir = 0x0;
        
        // just in case
        if ( new_obj == 0x0 || root_dir == 0x0 )
                return;
        
        // to get subdir in which this object is
        MakeDir(fTopFolder, root_dir, true);
        TString path = "";
        if ( GetPathOf(fTopFolder,new_obj,path) ) {
                path.Prepend( Form("%s/",fTopFolder->GetName()) );
                obj_dir = root_dir->GetDirectory(path.Data());
        }
        if ( obj_dir == 0x0 ) {
                return;
        }
        Bool_t def = TH1::AddDirectoryStatus();
        TH1::AddDirectory(false);       
        
        // useful to browse the TDirectory
        TString obj_name = new_obj->GetName(); TObject *obj_in_file = 0x0; TKey *key_in_file; Int_t cycle = 0; 
        
        // iterate over the associated to see if there is already an object saved with the same name
        TIter it(obj_dir->GetListOfKeys());
        // start
        while ( (key_in_file = static_cast<TKey *>(it())) ) { // next key               
                if ( obj_name == key_in_file->GetName() && new_obj->InheritsFrom(key_in_file->GetClassName()) )
                        if ( key_in_file->GetCycle() > cycle ) {
                                cycle = key_in_file->GetCycle();
                                if ( obj_in_file )
                                        delete obj_in_file; // delete previous allocated object
                                obj_in_file = key_in_file->ReadObj();
                        }               
        }       
        // copy the content of the object in file to the one in memory
        if ( obj_in_file ) {
//              RemoveFromDir(obj_in_file, gDirectory);
                obj_in_file->Copy(*new_obj);    
        }
        TH1::AddDirectory(def);         

        if ( obj_in_file ) 
                delete obj_in_file; // explicitely delete the object from the file otherwise done in Append.    
}

TObject *Watcher::AddToPool(TObject *new_obj)
{
        // just in case
        if ( new_obj == 0x0 )
                return 0x0;

        // add it to the pool
        fPoolOfObjects.AddLast(new_obj); 
        
        return new_obj;
}

void Watcher::SetDirectory(TDirectory *mother_watcher_dir, TDirectory *mother_tag, Bool_t load_objects)
{       
        fDirectory = mother_watcher_dir; fTagDirectory = mother_tag;
        
        // if load, try and load
        if ( load_objects ) {
                if ( mother_watcher_dir )
                        MakeDir(fTopFolder, mother_watcher_dir,true);
                if ( mother_tag && mother_tag != mother_watcher_dir )
                        MakeDir(fTopFolder, mother_tag,true);
                
                TObject *obj;
                if ( fDirectory ) {
                        TIter next_pool(&fPoolOfObjects);
                        while ( (obj = next_pool()) ) {
                                LoadObject(obj, fDirectory);
                        }
                }
                if ( fTagDirectory ) {
                        TIter next_pool(&fReference);                   
                        while ( (obj = next_pool()) ) {
                                LoadObject(obj, fTagDirectory);
                        }
                }               
        }
        
        return;
        
        /*
        TDirectory *c_dir = fDirectory;
        
        if ( mother_watcher_dir == 0x0 && fDirectory == 0x0 ) { // nothing to be changed
                if ( mother_tag == 0x0 && fTagDirectory == 0x0 )
                         return;
        }
        
        if ( mother_watcher_dir == 0x0 ) { // means no current directory for the object in the pool
                fDirectory = 0x0;       
        }
        else { 
                // first check if the subdirectory for this watcher exists if not it creates
                // in case of problems, the Watcher dir is set to 0x0
                TDirectory *tmp = mother_watcher_dir->GetDirectory(GetName());
                if ( tmp == 0x0 ) {
                        tmp = mother_watcher_dir->mkdir(GetName(),GetTitle());
                        if ( tmp )
                                fDirectory = tmp;
                        else 
                                fDirectory = 0x0;
                }
                else fDirectory = tmp;          
        }
        // now change the directory of the objects in the pool
        DirToDir(c_dir, fDirectory, fPoolOfObjects, load_objects);
        
        if ( mother_tag == 0x0 ) { // means no current directory for the object in the pool
                fTagDirectory = 0x0;    
        }
        else { 
                // first check if the subdirectory for this watcher exists if not it creates
                // in case of problems, the Watcher dir is set to 0x0
                TDirectory *tmp = mother_tag->GetDirectory(GetName());
                if ( tmp == 0x0 ) {
                        tmp = mother_tag->mkdir(GetName(),GetTitle());
                        if ( tmp )
                                fTagDirectory = tmp;
                        else 
                                fTagDirectory = 0x0;
                }
                else fTagDirectory = tmp;               
        }
        // now change the directory of the objects in the pool
        DirToDir(c_dir, fTagDirectory, fReference, load_objects);
         */
}

UInt_t Watcher::Snapshot(Option_t *opt)
{
        TString o = opt; TObject *obj; Bool_t save_tagged = true; UInt_t bytes = 0u;
        
        // make sure the destination directory are with subdirs.
        MakeDir(fTopFolder,fDirectory,true);
        if ( fDirectory != fTagDirectory )
                MakeDir(fTopFolder,fTagDirectory,true);
        
        if ( o.Contains("!tag")) {
                //
                save_tagged = false;
                //
                o.ReplaceAll("!tag",""); o.ReplaceAll(" ","");
        }
        if ( o == "*" ) { // save all
                if ( fDirectory ) {
                        TIter next_pool(&fPoolOfObjects);
                        while ( (obj = next_pool()) ) {
                                // To get the real directory since a watcher can have sub-directories
                                TString path = ""; TDirectory *dir = 0x0;
                                if ( GetPathOf(fTopFolder,obj,path) ) {
                                        path.Prepend( Form("%s/",fTopFolder->GetName()) );
                                        dir = fDirectory->GetDirectory(path.Data());                                    
                                        bytes += dir->WriteTObject(obj);
                                }                       
                        }
                }
                if ( save_tagged && fTagDirectory ) {
                        TIter next_tag(&fReference);
                        while ( (obj = next_tag()) ) {
                                // To get the real directory since a watcher can have sub-directories
                                TString path = ""; TDirectory *dir = 0x0;
                                if ( GetPathOf(fTopFolder,obj,path) ) {
                                        path.Prepend( Form("%s/",fTopFolder->GetName()) );
                                        dir = fTagDirectory->GetDirectory(path.Data());                                 
                                        bytes += dir->WriteTObject(obj);
                                }                       
                        }                       
                }
        }
        else {

        Bool_t wildcard = false;
        if ( o.Contains("*") )
            wildcard = true;
                TRegexp rexp(Form("%s",o.Data()),wildcard);
                
                if ( rexp.Status() == TRegexp::kOK ) {
                        TIter next_pool(&fPoolOfObjects);
                        while ( (obj = next_pool()) ) {
                                // To get the real directory since a watcher can have sub-directories
                                TString path = ""; TDirectory *dir = 0x0;
                                if ( GetPathOf(fTopFolder,obj,path) ) {
                                        path.Prepend( Form("%s/",fTopFolder->GetName()) );
                                        dir = fDirectory->GetDirectory(path.Data());                                    
                                        bytes += dir->WriteTObject(obj);
                                }                       
                        }
                        TIter next_tag(&fTagged);
                        while ( (obj = next_tag()) ) {
                                // To get the real directory since a watcher can have sub-directories
                                TString path = ""; TDirectory *dir = 0x0;
                                if ( GetPathOf(fTopFolder,obj,path) ) {
                                        path.Prepend( Form("%s/",fTopFolder->GetName()) );
                                        dir = fTagDirectory->GetDirectory(path.Data());                                 
                                        bytes += dir->WriteTObject(obj);
                                }                       
                        }
                }
        }
        // now call watchers of this 
        TIter loopontask(GetListOfTasks());
        Watcher *watcher;
        while ( ((watcher=(Watcher*)loopontask())) ) {
                bytes += watcher->Snapshot(opt);
        }
                
        return bytes;
}


void Watcher::Zero(Option_t *opt1, Option_t *opt2)
{       
        /*
        TString o1 = opt1; TRegexp rexp(Form("%s",opt1)); std::string o2 = opt2; 
        Bool_t is_bin = false;
        Int_t binx, biny, binz; Stat_t xmin, xmax, ymin, ymax, zmin, zmax;
        
        // set the method in Log
        fLog.SetProcessMethod("Zero");
        
        // try to decode the new spectrum definition if given
        if ( o2 != "" ) {
                // to avoid error due to end of line
                o2 += " ";
                // try to read the new spectra definition
                std::istringstream decode(o2);
                decode.clear();
                
                // xdef
                decode >> binx >> xmin >> xmax;
                if ( decode.good() )
                        is_bin = true;
                // ydef. if not given or wrong reading, set to x
                decode >> biny >> ymin >> ymax;
                if ( !decode.good() ) {
                        biny = binx;
                        ymin = xmin;
                        ymax = xmax;
                }
                decode >> binz >> zmin >> zmax;
                if ( !decode.good() ) {
                        binz = binx;
                        zmin = xmin;
                        zmax = xmax;
                }               
        }
        // filter on the name of the spectrum
        if ( o1.Contains("pool") ) 
                rexp = " *";    
        
        // to correct a bug in case only * is given
        if ( o1 == "*" )
                rexp = " *";
        if ( o1 == "" || rexp.Status() != TRegexp::kOK )
                rexp = "AbsolutelyNotAFilter";

        // apply to pool 
        for (Int_t i = 0; i < fPoolOfObjects.GetEntries(); i++) {
                TH1 *h = (TH1 *)fPoolOfObjects.At(i);
                if ( h ) {
                        TString hname = h->GetName();
                        
                        if ( hname.Contains(rexp) ) {
                                
                                fLog << info << " Reset " << hname << nline;

                                h->Reset("ICE");
                                if ( is_bin && h->GetDimension() == 1 ) 
                                        h->SetBins(binx,xmin,xmax);
                                if ( is_bin && h->GetDimension() == 2 ) 
                                        h->SetBins(binx,xmin,xmax,biny,ymin,ymax);      
                                if ( is_bin && h->GetDimension() == 3 ) 
                                        h->SetBins(binx,xmin,xmax,biny,ymin,ymax,binz,zmin,zmax);                                               
                        }
                }
        }
        
        // send the messages to the log collector
        fLog << dolog ; */
        
        TString o1 = opt1; std::string o2 = opt2;
    Bool_t wildcard = false;
    if ( o1.Contains("*") )
        wildcard = true;
    TRegexp rexp(Form("%s",opt1),wildcard);
    
        Bool_t is_bin = false;
        Int_t binx, biny, binz; Stat_t xmin, xmax, ymin, ymax, zmin, zmax;
        
        // set the method in Log
        fLog.SetProcessMethod("Zero");
        
        // try to decode the new spectrum definition if given
        if ( o2 != "" ) {
                // to avoid error due to end of line
                o2 += " ";
                // try to read the new spectra definition
                std::istringstream decode(o2);
                decode.clear();
                
                // xdef
                decode >> binx >> xmin >> xmax;
                if ( decode.good() )
                        is_bin = true;
                // ydef. if not given or wrong reading, set to x
                decode >> biny >> ymin >> ymax;
                if ( !decode.good() ) {
                        biny = binx;
                        ymin = xmin;
                        ymax = xmax;
                }
                decode >> binz >> zmin >> zmax;
                if ( !decode.good() ) {
                        binz = binx;
                        zmin = xmin;
                        zmax = xmax;
                }               
        }
        // filter on the name of the spectrum
        if ( o1.Contains("pool") ) 
                rexp = " *";    
        // to correct a bug in case only * is given
        if ( o1 == "*" )
                rexp = " *";
        if ( ( o1 == "" ) || (rexp.Status() != TRegexp::kOK) ) {
                fLog << info << " BAD expression  " << o1 << nline;
                rexp = "AbsolutelyNotAFilter";
        }
        
        
        // apply to pool 
        for (Int_t i = 0; i < fPoolOfObjects.GetEntries(); i++) {
                TH1 *h = (TH1 *)fPoolOfObjects.At(i);
                if ( h ) {
                        fLog << info << " Checking " << h->GetName() << " " ;

                        TString hname = h->GetName();
                        
                        if ( hname.Contains(rexp) ) {
                                
                                fLog << info << " ==> Reset " << hname;
                                
                                h->Reset(""); 
                                
                                if ( is_bin && h->GetDimension() == 1 ) 
                                        h->SetBins(binx,xmin,xmax);
                                if ( is_bin && h->GetDimension() == 2 ) 
                                        h->SetBins(binx,xmin,xmax,biny,ymin,ymax);      
                                if ( is_bin && h->GetDimension() == 3 ) 
                                        h->SetBins(binx,xmin,xmax,biny,ymin,ymax,binz,zmin,zmax);                                               
                        }
                        fLog << nline;
                }
        }
        //      apply to tag
        if ( o1.Contains("tag") )
                rexp = " *";    
        for (Int_t i = 0; i < fReference.GetEntries(); i++) {
                TH1 *h = (TH1 *)fReference.At(i);
                if ( h ) {
                        fLog << info << " Checking " << h->GetName() << " " ;

                        TString hname = h->GetName();
                        
                        if ( hname.Contains(rexp) ) {
                                
                                fLog << info << " ==> Reset " << hname << nline;
                                
                                h->Reset("");
                                if ( is_bin && h->GetDimension() == 1 ) 
                                        h->SetBins(binx,xmin,xmax);
                                if ( is_bin && h->GetDimension() == 2 ) 
                                        h->SetBins(binx,xmin,xmax,biny,ymin,ymax);      
                                if ( is_bin && h->GetDimension() == 3 ) 
                                        h->SetBins(binx,xmin,xmax,biny,ymin,ymax,binz,zmin,zmax);                                               
                        }
                        fLog << nline;
                }
        }
        
        // send the messages to the log collector
        fLog << dolog ; 
        
}
        
Bool_t Watcher::GetFromTrigger(DFTrigger *trigger, const char *type, SharedFP *&sfp)
{
        Bool_t ok = false; sfp = 0x0;
        
        // check if this trigger is not a zombie
        if ( ! Watcher::SetTrigger(trigger) )
                return false;
        
        // loop the different input frames to look for a t one, whatever the version
        SharedFP *ffind = 0x0; 
        UInt_t which;
        for( which = 0u; which < GetTrigger()->GetNbInputFrame(); which++){
                
                SharedFP *fp = GetTrigger()->GetInputSharedFP(which);
                if ( fp == 0x0 )
                        continue;
                
                Frame *f = fp->GetFrame();
                if ( f == 0x0 )
                        continue;
                
                TString ftype = f->GetSignature().GetItemName();
                
                // check if the current frame is a version of a type frame
                if ( ftype.Contains(type) ) {
                        ffind = fp;
                        break;
                }
        }
        if ( ffind )
        { ok = true; sfp = ffind; }
        else 
        { sfp = 0x0; }  
        
        return ok;      
}

Bool_t Watcher::SetTrigger(ADF::DFTrigger *trigger)
{ 
        if ( trigger == 0x0 )
                return false;
        if ( trigger->IsZombie() )
                return false;
        
        fTrigger = trigger;
        
        return true;    
}

void Watcher::CleanTasks()
{
        if (fBreakin)  
                        fBreakin  = 1;
   if (fBreakout) 
                        fBreakout = 1;
   fHasExecuted = kFALSE;
        
   Clear();
        
        TTask *task; TObjLink *lnk = fTasks->FirstLink();
        while (lnk) {
                task = (TTask *)lnk->GetObject();
        if ( task == 0x0 ) {
            continue;
        }
                task->CleanTasks();
                lnk = lnk->Next();
        }
}

void Watcher::Pass()
{
        // force execution flag to true
        fHasExecuted = true;
        
        TTask *task; TObjLink *lnk = GetListOfTasks()->FirstLink();
        while (lnk) {
                task = (TTask *)lnk->GetObject();
        if ( task == 0x0 ) {
            continue;
        }
                if ( !task->IsActive() ) {
                        lnk = lnk->Next();
                        continue;       
                }
                Watcher *watcher = 
                        dynamic_cast<Watcher *>(task);
                if ( watcher ) {
                        watcher->Pass();        
                }
                        
                lnk = lnk->Next();
        }
        
        /* seen as time consuming by shark (macosx) since allocation of TIter !
        TIter loopontask(GetListOfTasks());
        TTask *task;
        while ( ((task=(TTask*)loopontask())) ) {
                if ( !task->IsActive() )
                        continue;       
                Watcher *watcher = 
                        dynamic_cast<Watcher *>(task);
                if ( watcher ) {
                        watcher->Pass();        
                }
        }       
         */
}

void Watcher::TagOn(TObject *o)
{       
        // already in the tagged collection
        if ( fTagged.FindObject(o) )
                return;
        
        TString oname = o->GetName();
        oname += "_Ref";
        
        // clone from o and change attributes in case we would like to display on the same pad
        TObject *oref = o->Clone(oname.Data());
        // to avoid having tag in the current dir
        RemoveFromDir(oref, gDirectory);
        
        if ( oref->InheritsFrom("TAttFill") ) {
                TAttFill *att = dynamic_cast<TAttFill *>(oref);
                if ( att ) {
                        att->SetFillColor(kRed);
                        att->SetFillStyle(3004);
                }
        }
        if ( oref->InheritsFrom("TAttLine") ) {
                TAttLine *att = dynamic_cast<TAttLine *>(oref);
                if ( att ) {
                        att->SetLineColor(kRed);
                        att->SetLineStyle(2);
                }
        }       
        // add to the folder 
        TString tmp(""); 
        if ( GetPathOf(fTopFolder,o,tmp) ) {
                TFolder *folder = GetSubFolder(fTopFolder,tmp.Data());
                folder->Add(oref); 
        }
        
        // takes care of filling the content of the object in memory with the content of the object on disk 
        LoadObject(oref, fTagDirectory);
        
        // collection of tag objects
        fTagged.Add(o); fReference.Add(oref);   
}

Bool_t Watcher::TestTag(Option_t *opt) 
{ 
        Double_t valtest_i = 0.0, valtest_t = 0.0; UInt_t nbtest = 0u; TString option(opt);
        
        TObject *obj, *objref;
        for (Int_t i = 0u; i < fTagged.GetEntries(); i++ ) {
                obj     = fTagged.At(i);
                objref  = fReference.At(i);
                
                if ( obj->InheritsFrom("TH1") ) {
                        
                        TH1 *h     = (TH1 *)obj;
                        TH1 *h_ref = (TH1 *)objref;
                        
                        Double_t h_ref_i = h_ref->Integral();
                        Double_t h_i = h->Integral();
                        
                        if ( h_ref_i > 0.0 && h_i > 0.0 ) {
                                
                                nbtest++;

                                valtest_i  = h_ref->KolmogorovTest(h,opt);
                                valtest_t += valtest_i;
                                
                                if ( option.Contains("v") )
                                        printf("KolmogorovTest for %s : %f \n",h->GetName(),valtest_i);
                                
                                // apply scaling to tag to match current histogram
                                h_ref->Scale( h_i / h_ref_i );
                        }
                        
                }
        }
        if ( nbtest ) 
                valtest_t /= nbtest;
        else 
                return true;
        
        if ( option.Contains("v") )
                printf("KolmogorovTest in WatcherWithTag::TestTag : %f \n",valtest_t);  
        
        return (valtest_t > 0.01); 
} 

void Watcher::Tag(Option_t * /*opt*/) 
{
        TObject *obj, *objref;
        for (Int_t i = 0u; i < fTagged.GetEntries(); i++ ) {
                obj     = fTagged.At(i);
                objref  = fReference.At(i);
                
                if ( obj->InheritsFrom("TH1") ) {
                        TH1 *h     = (TH1 *)obj;
                        TH1 *h_ref = (TH1 *)objref;
                        
                        h_ref->Reset(); h_ref->Add(h);
                }
        }
}

void Watcher::DrawTag(TCanvas *c, Option_t *o) 
{
        if ( fTagged.GetEntries() == 0 ) 
                return;
        
        TString opt = o;
        
        // perform pad division
        if ( fTagged.GetEntries() > 1 ) {
                // division of the pad 
                Int_t nx = -1, ny = -1; 
                // check if not given is the option
                TRegexp expected("tag*x*",true);
                if ( opt.Contains(expected) ) {
                        Ssiz_t tag = opt.First("tag");
                        Ssiz_t x   = opt.First("x");
                        TString val_nx = opt(tag+3,x-tag);
                        TString val_ny = opt(x+1,2);
                        
                        if ( val_nx.IsAlnum() && val_ny.IsAlnum() ) {
                                nx = val_nx.Atoi();
                                ny = val_ny.Atoi();
                        }
                }
                // search square that gives enough pads 
                if ( nx == -1 || ny == -1 ) {
                        if ( fTagged.GetEntries() == 2 ) {
                                nx = 1;
                                ny = 2;
                        }
                        else 
                                for (Int_t i = 1u; i < fTagged.GetEntries(); i++ ) 
                                        if ( i*i > fTagged.GetEntries() ) {
                                                nx = i;
                                                ny = i;
                                        }       
                }
                c->Divide(nx,ny);
        }
        // draw a taggued obj and its ref in the same pad
        TObject *obj, *objref;
        for (Int_t i = 0u; i < fTagged.GetEntries(); i++ ) {
                
                obj     = fTagged.At(i);
                objref  = fReference.At(i);
                
                c->cd(i+1);
                
                obj->Draw();
                objref->Draw("same");
        }
}


TCanvas *Watcher::NewCanvas(Option_t *o)
{
        TString option = o, cname; Bool_t is_ogl = option.Contains("OGL", TString::kIgnoreCase);
        
        option.ReplaceAll("OGL", "");
        option.ReplaceAll(" ", "_");
        
//      if ( fDirectory )
//              if ( fDirectory->GetMotherDir() )
//                      cname  = fDirectory->GetMotherDir()->GetName(); 

        cname = GetName();      
        if ( !option.IsNull() ) {
                cname += "_";
                cname += option;
        }
        
        // check if TRootBrowserLite is used by trying to plug a new canvas
        // if fails, open a standard canvas
        TCanvas *cnew = 0x0;
        TBrowser *br = (TBrowser *)gROOT->GetListOfBrowsers()->At(0);
        if ( br && is_ogl == false ) {
                
                TString cmd;
                cmd = Form("new TCanvas(\"%s\",\"%s\")",cname.Data(),cname.Data());
                
                br->ExecPlugin(cname.Data(), 0, cmd.Data()) ;
                cnew = (TCanvas *)gROOT->GetListOfCanvases()->FindObject(cname.Data()); 
        }
        if ( cnew == 0x0 ) {
                gStyle->SetCanvasPreferGL(is_ogl); 
                cnew = new TCanvas(cname.Data(),cname.Data(),700,500);
                gStyle->SetCanvasPreferGL(false); 
        }
        
        return cnew;
}

void Watcher::ShowCanvas(Option_t *o)
{
        TString option = o, cname;

        option.ReplaceAll("OGL", "");
        option.ReplaceAll(" ", "_");
        
        if ( fDirectory )
                if ( fDirectory->GetMotherDir() )
                        cname  = fDirectory->GetMotherDir()->GetName(); 
        cname += ":";
        cname += GetName();     
        if ( !option.IsNull() ) {
                cname += "_";
                cname += option;
        }
        
        // the canvas is already displayed ... just refresh needed !
        if ( gROOT->GetListOfCanvases()->FindObject(cname.Data()) ) 
                return;
                
        TCanvas *c = NewCanvas(o);
        if ( c )
                { c->cd(); DoCanvas(c,o); }
}

ClassImp(WatcherWithTag);

WatcherWithTag::WatcherWithTag() : 
        Watcher()
{ 

}       

WatcherWithTag::WatcherWithTag(const char *name, const char *title, TDirectory *mother_dir_of_watcher, TDirectory *mother_dir_tag) : 
        Watcher(name,title,mother_dir_of_watcher,mother_dir_tag)
{ 
}


/*
void WatcherWithTag::Add(TTask *task)
{
        // everything is defined for that trigger 
        if ( task == 0x0 || fTrigger == 0x0 )
                return;
        if ( fTrigger->IsZombie() )
                return;
        
        // add only watcher with a correct trigger 
        Watcher *watcher = 
        dynamic_cast<Watcher *>(task);
        if ( watcher ) {
                TTask::Add(watcher);
                // Watcher defined without trigger so use this one 
                if ( watcher->GetTrigger() == 0x0 )
                        watcher->SetTrigger(fTrigger);
                if ( fDirectory )
                        watcher->SetDirectory(fDirectory,fTagDirectory);
        }
}

void WatcherWithTag::TagOn(TObject *o)
{       
        // already in the tagged collection
        if ( fTagged.FindObject(o) )
                return;
                        
        TString oname = o->GetName();
        oname += "_Ref";
        
        // clone from o and change attributes in case we would like to display on the same pad
        TObject *oref = o->Clone(oname.Data());
        
        if ( oref->InheritsFrom("TAttFill") ) {
                TAttFill *att = dynamic_cast<TAttFill *>(oref);
                if ( att ) {
                        att->SetFillColor(kRed);
                        att->SetFillStyle(3004);
                }
        }
        if ( oref->InheritsFrom("TAttLine") ) {
                TAttLine *att = dynamic_cast<TAttLine *>(oref);
                if ( att ) {
                        att->SetLineColor(kRed);
                        att->SetLineStyle(2);
                }
        }       
        // remove object from the gDirectory and fDirectory
        RemoveFromDir(oref, gDirectory);
        if ( fDirectory != fTagDirectory ) 
                RemoveFromDir(oref, fDirectory);
        
        // takes care of filling the content of the object in memory with the content of the object on disk 
        LoadObject(oref, fTagDirectory);
        
        // collection of tag objects
        fTagged.Add(o); fReference.Add(oref);   
}

void WatcherWithTag::SetDirectory(TDirectory *mother_watcher_dir, TDirectory *mother_tag, Bool_t load_objects)
{       
        // first change directory for histograms in the pool
        Watcher::SetDirectory(mother_watcher_dir,mother_tag,load_objects);
        
        TDirectory *c_dir = fTagDirectory;
                
        if ( mother_tag == 0x0 && fTagDirectory == 0x0 ) // nothing to be changed
                return;
        
        if ( mother_tag == 0x0 ) { // means no current directory for the object in the pool
                fTagDirectory = 0x0;    
        }
        else { 
                // first check if the subdirectory for this watcher exists if not it creates
                // in case of problems, the Watcher dir is set to 0x0
                TDirectory *tmp = mother_tag->GetDirectory(GetName());
                if ( tmp == 0x0 ) {
                        tmp = mother_tag->mkdir(GetName(),GetTitle());
                        if ( tmp )
                                fTagDirectory = tmp;
                        else 
                                fTagDirectory = 0x0;
                }
                else fTagDirectory = tmp;               
        }
        // now change the directory of the objects in the pool
        DirToDir(c_dir, fTagDirectory, fReference, load_objects);

}

void WatcherWithTag::Zero(Option_t *opt1, Option_t *opt2)
{
        
        TString o1 = opt1; TRegexp rexp(Form("%s",opt1)); std::string o2 = opt2; 
        Bool_t is_bin = false;
        Int_t binx, biny, binz; Stat_t xmin, xmax, ymin, ymax, zmin, zmax;
        
        // set the method in Log
        fLog.SetProcessMethod("Zero");
        
        // try to decode the new spectrum definition if given
        if ( o2 != "" ) {
                // to avoid error due to end of line
                o2 += " ";
                // try to read the new spectra definition
                std::istringstream decode(o2);
                decode.clear();
                
                // xdef
                decode >> binx >> xmin >> xmax;
                if ( decode.good() )
                        is_bin = true;
                // ydef. if not given or wrong reading, set to x
                decode >> biny >> ymin >> ymax;
                if ( !decode.good() ) {
                        biny = binx;
                        ymin = xmin;
                        ymax = xmax;
                }
                decode >> binz >> zmin >> zmax;
                if ( !decode.good() ) {
                        binz = binx;
                        zmin = xmin;
                        zmax = xmax;
                }               
        }
        // filter on the name of the spectrum
        if ( o1.Contains("pool") ) 
                rexp = " *";    
        // to correct a bug in case only * is given
        if ( o1 == "*" )
                rexp = " *";
        if ( ( o1 == "" ) || (rexp.Status() != TRegexp::kOK) ) {
                fLog << info << " BAD expression  " << nline;
                rexp = "AbsolutelyNotAFilter";
        }
        
        
        // apply to pool 
        for (Int_t i = 0; i < fPoolOfObjects.GetEntries(); i++) {
                TH1 *h = (TH1 *)fPoolOfObjects.At(i);
                
                fLog << info << " Checking " << h->GetName() << nline;
                
                if ( h ) {
                        TString hname = h->GetName();
                        
                        if ( hname.Contains(rexp) ) {
                                
                                fLog << info << " Reset " << hname << nline;
                                
                                h->Reset(""); 
                                
                                if ( is_bin && h->GetDimension() == 1 ) 
                                        h->SetBins(binx,xmin,xmax);
                                if ( is_bin && h->GetDimension() == 2 ) 
                                        h->SetBins(binx,xmin,xmax,biny,ymin,ymax);      
                                if ( is_bin && h->GetDimension() == 3 ) 
                                        h->SetBins(binx,xmin,xmax,biny,ymin,ymax,binz,zmin,zmax);                                               
                        }
                }
        }
        //      apply to tag
        if ( o1.Contains("tag") )
                rexp = " *";    
        for (Int_t i = 0; i < fReference.GetEntries(); i++) {
                TH1 *h = (TH1 *)fReference.At(i);
                if ( h ) {
                        TString hname = h->GetName();
                        
                        if ( hname.Contains(rexp) ) {
                                
                                fLog << info << " Reset " << hname << nline;
                                
                                h->Reset("ICE");
                                if ( is_bin && h->GetDimension() == 1 ) 
                                        h->SetBins(binx,xmin,xmax);
                                if ( is_bin && h->GetDimension() == 2 ) 
                                        h->SetBins(binx,xmin,xmax,biny,ymin,ymax);      
                                if ( is_bin && h->GetDimension() == 3 ) 
                                        h->SetBins(binx,xmin,xmax,biny,ymin,ymax,binz,zmin,zmax);                                               
                        }
                }
        }
        
        // send the messages to the log collector
        fLog << dolog ;
}

Bool_t WatcherWithTag::TestTag(Option_t *opt) 
{ 
        Double_t valtest = 0.0; UInt_t nbtest = 0u;
        
        TObject *obj, *objref;
        for (Int_t i = 0u; i < fTagged.GetEntries(); i++ ) {
                obj     = fTagged.At(i);
                objref  = fReference.At(i);
                
                if ( obj->InheritsFrom("TH1") ) {
                        TH1 *h     = (TH1 *)obj;
                        TH1 *h_ref = (TH1 *)objref;
                                
                        nbtest++;
                        valtest += h_ref->KolmogorovTest(h,opt);
                        
                        printf("KolmogorovTest for %s : %f \n",h->GetName(),valtest);
                }
        }
        if ( nbtest ) 
                valtest /= nbtest;
                
        printf("KolmogorovTest in WatcherWithTag::TestTag : %f \n",valtest);    
        
        return (valtest > 0.01); 
} 

void WatcherWithTag::Tag(Option_t *opt) 
{
        TObject *obj, *objref;
        for (Int_t i = 0u; i < fTagged.GetEntries(); i++ ) {
                obj     = fTagged.At(i);
                objref  = fReference.At(i);
                
                if ( obj->InheritsFrom("TH1") ) {
                        TH1 *h     = (TH1 *)obj;
                        TH1 *h_ref = (TH1 *)objref;
                        
                        h_ref->Reset(); h_ref->Add(h);
                }
        }
}

void WatcherWithTag::DrawTag(TCanvas *c, Option_t *o) 
{
        if ( fTagged.GetEntries() == 0 ) 
                return;
                
        TString opt = o;
        
        // perform pad division
        if ( fTagged.GetEntries() > 1 ) {
                // division of the pad 
                Int_t nx = -1, ny = -1; 
                // check if not given is the option
                TRegexp expected("tag*x*");
                if ( opt.Contains(expected) ) {
                        Ssiz_t tag = opt.First("tag");
                        Ssiz_t x   = opt.First("x");
                        TString val_nx = opt(tag+3,x-tag);
                        TString val_ny = opt(x+1,2);
                        
                        if ( val_nx.IsAlnum() && val_ny.IsAlnum() ) {
                                nx = val_nx.Atoi();
                                ny = val_ny.Atoi();
                        }
                }
                // search square that gives enough pads 
                if ( nx == -1 || ny == -1 ) {
                        if ( fTagged.GetEntries() == 2 ) {
                                nx = 1;
                                ny = 2;
                        }
                        else 
                          for (Int_t i = 1u; i < fTagged.GetEntries(); i++ ) 
                                if ( i*i > fTagged.GetEntries() ) {
                                        nx = i;
                                        ny = i;
                                }       
                }
                c->Divide(nx,ny);
        }
        // draw a taggued obj and its ref in the same pad
        TObject *obj, *objref;
        for (Int_t i = 0u; i < fTagged.GetEntries(); i++ ) {
        
                obj     = fTagged.At(i);
                objref  = fReference.At(i);
                
                c->cd(i+1);
                
                obj->Draw();
                objref->Draw("same");
        }
}
*/

ClassImp(LoopControl);

LoopControl::LoopControl(TTask *mother, TDirectory *dir_watchers, TDirectory *dir_tags) : 
        WatcherWithTag("LoopControl","To control the main loop",dir_watchers,dir_tags),
        fLoopTime(0x0), 
        fTimeControl(),
        fDelta(10000),
        fMother(mother),
        fMotherDirWatcher(dir_watchers),
        fMotherDirTag(dir_tags),
        fTimer ( new TTimer() ),
        fLastSaveArg1(""),
        fLastSaveArg2(""),
        fLastSaveArg3(";"),
        fLastSaveArg4(0)
{
        // variable size bin to have 
        /*
        const UShort_t knb_bins = 500;
        Float_t t[knb_bins];
        for (UShort_t i = 0u; i < 500; i++ ){
                
        }
        */
        fLoopTime = MakeTH1<TH1F>("LoopTime","Time to execute one loop [ms]",1000,0,0.01);
        TagOn(fLoopTime);
        
        //
        fTimer->Connect("Timeout()", "Gw::LoopControl", this, "AutoSave()");
}

LoopControl::~LoopControl()
{
        fTimer->Disconnect("Timeout()",this, "AutoSave()");
}

void LoopControl::Zero(Option_t *opt1, Option_t *opt2)
{       
        // call Zero for all watchers 
        TIter next(fMother->GetListOfTasks());
        TTask *task;
        while ( (task = (TTask *)next()) ) {
                if (  task == this )
                        continue;
                Watcher *w = dynamic_cast<Watcher *> (task);
                if ( w ) {              
                        w->Zero(opt1,opt2);
                }
        }       
}

void LoopControl::Save(const Char_t *main_file, const Char_t *tag_file, const Char_t *option, Int_t autotime)
{       
        // useful directories
        TString dir_w_name = main_file, dir_tag_name = tag_file; TDirectory *dir_w = fMotherDirWatcher, *dir_tag = fMotherDirTag;
        TString opt_w = option, opt_tag = option;
        // to avoid deleting twice the same dir 
    Bool_t do_delete_w = false, do_delete_tag = false/*, is_write_called = false*/; UInt_t bytes = 0u;
        
        // dir_w may be different that fMotherDirWatcher
        if ( dir_w_name != "" ) {  
                // if 0 means does not save 
                if ( dir_w_name == "0"  ) {
                        dir_w = 0x0; 
                }
                // means a new root file
                else {
                        if ( opt_w == "" )
                                opt_w = "(;)"; // for safety in case option has not been set properly
                        
                        // name of the root file to be open
                        if ( opt_w.Contains("ch") ) { // 
                                // chain, next name is main_file_XXXX.root
                                Int_t i = 0;
                                while ( 1 ) {
                                        TString tmp = Form("%s%03d.root",main_file,i);
                                        if ( gSystem->AccessPathName(tmp.Data()) ) {
                                                dir_w_name = tmp;
                                                break;
                                        }
                                        else i++;
                                }
                        }
                        else {
                                if ( ! dir_w_name.Contains(".root") )
                                        dir_w_name += ".root";                          
                        }                       
                        if ( dir_w ) {
                                // check if not the same name that the current one
                                if ( dir_w_name != dir_w->GetName() ) {
                                        // open a new ROOT file
                                        dir_w = new TFile(dir_w_name.Data(),"UPDATE");
                                }
                        }
                }
        }
        else opt_w = ";"; // just save in the current dir.

        // dir_tag may be different that fMotherDirTag
        if ( dir_tag_name != "" ) {  
                if ( dir_tag_name == "+" ) {
                        dir_tag = dir_w;
                }
                // if 0 means does not save 
                if ( dir_tag_name == "0"  ) {
                        dir_tag = 0x0; 
                }
                // means a new root file
                else {
                        if ( opt_tag == "" )
                                opt_tag = "(;)"; // for safety in case option has not been set properly
                        
                        // name of the root file to be open
                        if ( opt_tag.Contains("ch") ) { // 
                                // chain, next name is tag_file_XXXX.root
                                Int_t i = 0;
                                while ( 1 ) {
                                        TString tmp = Form("%s%03d.root",tag_file,i);
                                        if ( gSystem->AccessPathName(tmp.Data()) ) {
                                                dir_tag_name = tmp;
                                                break;
                                        }
                                        else i++;
                                }
                        }
                        else {
                                if ( ! dir_tag_name.Contains(".root") )
                                        dir_tag_name += ".root";                                
                        }                       
                        if ( dir_tag ) {
                                // check if not the same name that the current one
                                if ( dir_tag_name != dir_tag->GetName() ) {
                                        // open a new ROOT file
                                        dir_tag = new TFile(dir_tag_name.Data(),"UPDATE");
                                }
                        }
                }
        }
        else opt_tag = ";"; // just save in the current dir.
        
        // now check option to know in which order the procedure should be called :
        // 0 : action is not done, 1 yes
        // action0 : save watchers in current dir
        // action1 : change dir of watchers
        // action2 : save watchers in new dir
        // action3 : adopt new dir of watchers
        // action4 : close the new file, and back to previous dir 
        Short_t action0 = 1, action1 = 0, action2 = 0, action3 = 0, action4 = 0;
        
        if ( opt_w.Contains(";(") ) { // write, change dirs and keep this dir open
                action0 = action1 = action3 = 1;
        }
        if ( opt_w.Contains("(;") ) { // change dirs of all watcher to new dir, write and keep the new dirs
                action0 = 0; action1 = action2 = action3 = 1;
                if ( opt_w.Contains(")") ) { // open the new file, write, close it and does not change current dirs
                        action3 = 0;
                        action4 = 1;
                }                               
        }       
        if ( dir_w == 0x0 ) 
                action0 = action1 = action2 = action3 = action4 = 0; // nothing to be done
        
        if ( action0 ) {
//              is_write_called = true;
                //
                TIter next(fMother->GetListOfTasks());
                TTask *task;
                while ( ((task=(TTask*)next())) ) {
                        Watcher *watcher = dynamic_cast<Watcher *> (task);
                        if ( watcher ) {
                                bytes += watcher->Snapshot();
                        }
                }               
                //
                std::cout << " Snapshot in " << dir_w->GetName() << " and " << dir_tag << std::endl ;
                std::cout << " ==> " << bytes << " bytes written " << std::endl;                
        }
        if ( action1 ) {
                // change dirs of Watchers
                TIter next(fMother->GetListOfTasks());
                TTask *task;
                while ( ((task=(TTask*)next())) ) {
                        Watcher *watcher = dynamic_cast<Watcher *> (task);
                        if ( watcher ) {
                                watcher->SetDirectory(dir_w,dir_tag,false);
                        }
                }                       
        }
        if ( action2 ) {
//              is_write_called = true;
                //
                TIter next(fMother->GetListOfTasks());
                TTask *task;
                while ( ((task=(TTask*)next())) ) {
                        Watcher *watcher = dynamic_cast<Watcher *> (task);
                        if ( watcher ) {
                                bytes += watcher->Snapshot();
                        }
                }               
                //              
                std::cout << " Snapshot in " << dir_w->GetName() << std::endl;
                std::cout << " ==> " << bytes << " bytes written " << std::endl; 
        }       
        if ( action3 ) {
                fMotherDirWatcher = dir_w ; fMotherDirTag = dir_tag ;
        }               
        if ( action4 > 0 ) {
                // change dirs of Watchers
                TIter next(fMother->GetListOfTasks());
                TTask *task;
                while ( ((task=(TTask*)next())) ) {
                        Watcher *watcher = dynamic_cast<Watcher *> (task);
                        if ( watcher )
                                watcher->SetDirectory(fMotherDirWatcher,fMotherDirTag,false);
                }       
                do_delete_w = true;
        }               
        /*
        // now check option to know in which order the procedure should be called :
        // 0 : action is not done, 1 yes
        // action0 : save watchers in current dir
        // action1 : change dir of watchers
        // action2 : save watchers in new dir
        // action3 : adopt new dir of watchers
        // action4 : close the new file, and back to previous dir 
        action0 = 1; action1 = action2 = action3 = action4 = 0;
        
        if ( opt_tag.Contains(";(") ) { // write, change dirs and keep this dir open
                action0 = action1 = action3 = 1;
        }
        if ( opt_tag.Contains("(;") ) { // change dirs of all watcher to new dir, write and keep the new dirs
                action0 = 0; action1 = action2 = action3 = 1;
                if ( opt_tag.Contains(")") ) { // open the new file, write, close it and does not change current dirs
                        action3 = 0;
                        action4 = 1;
                }                               
        }       
        if ( dir_tag == 0x0 ) 
                action0 = action1 = action2 = action3 = action4 = 0; // nothing to be done
        
        if ( action0 ) {
                if ( dir_tag == dir_w && is_write_called ) {
                }
                else {
                        std::cout << " Snapshot in " << dir_tag->GetName() << std::endl ;
                        std::cout << " ==> " << dir_tag->Write() << " bytes written " << std::endl; 
                }
        }
        if ( action1 ) {
                // change dirs of Watchers
                TIter next(fMother->GetListOfTasks());
                TTask *task;
                while ( ((task=(TTask*)next())) ) {
                        Watcher *watcher = dynamic_cast<Watcher *> (task);
                        if ( watcher )
                                watcher->SetDirectory(dir_w,dir_tag,false);
                }                       
        }
        if ( action2 ) {
                if ( dir_tag == dir_w && is_write_called ) {
                }
                else { 
                        std::cout << " Snapshot in " << dir_tag->GetName() << std::endl ;
                        std::cout << " ==> " << dir_tag->Write() << " bytes written " << std::endl; 
                }
        }       
        if ( action3 ) {
                fMotherDirTag = dir_tag ;
        }               
        if ( action4 ) {
                // change dirs of Watchers
                TIter next(fMother->GetListOfTasks());
                TTask *task;
                while ( ((task=(TTask*)next())) ) {
                        Watcher *watcher = dynamic_cast<Watcher *> (task);
                        if ( watcher )
                                watcher->SetDirectory(fMotherDirWatcher,fMotherDirTag,false);
                }               
                // delete 
                do_delete_tag = true;
        }       
*/
        // delete the open files if needed, just once in case dir_w and dir_tag are the same ! 
        if ( do_delete_w ) {
                delete dir_w;
                if ( do_delete_tag && dir_w != dir_tag ) 
                        delete dir_tag;
        }
        else {
                if ( do_delete_tag ) {
                        delete dir_tag;
                }
        }
        // call Zero if asked
        opt_w = option;
        if ( opt_w.Contains("{") && opt_w.Contains("}") ) {
                if ( opt_w.Index("{") < opt_w.Index("}") ) {
                        TString opt1, opt2;
                        if ( opt_w.Contains(":") && (opt_w.Index("{")< opt_w.Index(":")) && (opt_w.Index("}") > opt_w.Index(":")) ) {
                                opt1 = opt_w(opt_w.Index("{")+1,opt_w.Index(":")-opt_w.Index("{")-1); 
                                opt2 = opt_w(opt_w.Index(":")+1,opt_w.Index("}")-opt_w.Index(":")-1);
                        }
                        else {
                                opt1 = opt_w(opt_w.Index("{")+1,opt_w.Index("}")-opt_w.Index("{")-1);
                                opt2 = "";
                        }
                        std::cout << " Zero called with " << opt1 << " " << opt2 << std::endl ;
                        Zero(opt1.Data(),opt2.Data());
                }
        }
        
        // autocall if required. Stop with SetAutoTime()
        fLastSaveArg1 = main_file;
        fLastSaveArg2 = tag_file;
        fLastSaveArg3 = option;
        fLastSaveArg4 = 0; // needed, next calls are started automatically by timer
        //
        if ( autotime > 0 ) {
                fTimer->Start(autotime*1000, kFALSE);  
        }
}

void LoopControl::AutoSave()
{
        std::cout << " AUTOSAVE CALLED IN LoopControl with " << fLastSaveArg1 << " " << fLastSaveArg2 << " " << fLastSaveArg3 << std::endl ;
        //
        Save(fLastSaveArg1.Data(), fLastSaveArg2.Data(), fLastSaveArg3.Data(), fLastSaveArg4);
}

void LoopControl::SetAutoTime(Int_t autotime)
{
        fTimer->Stop(); fLastSaveArg4 = 0;

        // restart the autosave
        if ( autotime > 0 ) {
                fTimer->Start(autotime*1000, kFALSE);   // 
        }
        else { std::cout << " AUTOSAVE WITH " << fLastSaveArg1 << " " << fLastSaveArg2 << " " << fLastSaveArg3 << " Stopped " << std::endl ; }
}

/*
void LoopControl::ShowCanvas(Option_t *option)
{
        // collect Watchers  and call ShowCanvas for those which have a name that correspond to the pattern in option 
        TString pattern = option;
        //
        // loop on task to get FrameDispatchers
        TIter next(top_task->GetListOfTasks());
        while ( (task = (TTask *)next()) ) {
                if (  task == collector )
                        continue;
                fd = dynamic_cast<FrameDispatcher *> (task);
                if ( fd ) {             
                        TIter next_w(fd->GetListOfTasks());
                        while ( (task = (TTask *)next_w()) ) {
                                ts_rate = dynamic_cast<TSRate *> (task);
                                if ( ts_rate ) {
                                        collector->AddHook(ts_rate,fd->GetName());
                                }
                        }
                }
        }       
}
 */

void LoopControl::Exec(Option_t */*option*/)
{
        fTimeControl.Stop(); Double_t current_time_s = fTimeControl.RealTime(); 
        
// //   printf("Call %f %f \n",current_time_s,fDelta);
// 
//      if( current_time_s < fDelta ) {
// //           printf("Call sleep %d \n",Int_t((fDelta-current_time_s)*1000.));        
// //                   gSystem->Sleep(Int_t((fDelta-current_time_s)*1000.));
// //           printf("Call sleep done \n");
//              fCounterAdd++;
//      }
        
        if ( current_time_s < fDelta ) {
                fLoopTime->Fill(-1);
//              gSystem->Sleep(fDelta);         
        }
        else {
                fLoopTime->Fill(current_time_s/1000.);
        }
        fTimeControl.Start(kTRUE);      
}

void LoopControl::DoCanvas(TCanvas * /*c*/, Option_t *o)
{       
        TString opt = o;
        
        // in the task list, find mother of this
        if ( opt == "" ) {
                
        }
        else 
                fLoopTime->Draw(o); 
}

ClassImp(LoopOnTasks);
                
void LoopOnTasks::Exec(Option_t *option)
{       
        TString opt = option;
        
        if ( opt.Contains("l") ) {
                fIsLoop = true;
        }

        do {
                // Execute all active subtasks 
                ExecuteTasks("");
                
                // clean all the tasks for the next loop
                CleanTasks();
                
                // to be able to stop the loop 
                gSystem->ProcessEvents();

                if ( ! IsActive() )
                        { fIsLoop = false; }
                
        } while( fIsLoop );
}

Bool_t LoopOnTasks::HandleTimer(TTimer* /*timer*/)
{
        TTask::ExecuteTask(GetTitle()); 
        return true;
}

void LoopOnTasks::ExecuteTask(Option_t* option)
{
        if ( fIsLoop ) // already in loop
                return;
        fTimer->SetObject(this); SetTitle(option); fTimer->Start(20, kTRUE);
}

void LoopOnTasks::Abort()
{ 
        if ( fIsLoop ) 
                fIsLoop = false;
}

void LoopOnTasks::SetActive(Bool_t active) 
{ 
        // switch task off.
        if ( active == false && fIsLoop ) {
                fIsLoop = false;        
                SetTitle("l");
        }
        fActive = active; 
}