GANILLoadWatchers.C

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) IPNL, IN2P3, CNRS                                       *
 *   Contibutor(s) :                                                       *
 *      Jeremie Dudouet  dudouet(AT)ipnl.in2p3.fr [2014]                   *
 *      Olivier Stezowski stezow(AT)ipnl.in2p3.fr [2014]                   *
 *                                                                         *
 *   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.             *
 ***************************************************************************/

void LoadClass(TString cpp_path);
void AddInclude(TString what_directory);
void SetBasicMacros(TString what_file, TString what_sub_directory);
void BeginLoadWatchers();
void PreLoad();
void LoadVisuWatchers();
void LoadWatchers_AGATA();
void LoadWatchers_ANCILLARIES();
void LoadWatchers_MyWatchers();
void LoadSpectraViewer();
void EndLoadWatchers();
void BuildFolders();
void CleanWatchers();
void CleanDir(TString Dir);

// some globals protected by a namespace
namespace __LoadWatchers__ {
// used for subdirectories containing campaign related [in Default and Macros]
TString CAMPAIGN = "GANIL";

// to force compilation / debugging @ the ACLIC level
TString CompOpt = "";
// just a usefull String
TString tmp;
// path to agapro
TString AGAPRO;
// Has GANIL: tested in BeginWatchers, used by other methods
Bool_t HAS_GANIL = false; TString MFMDIR(""), VAMOSDIR(""), GRUDIR("");

Char_t DefaultW[100]; Char_t MyW[100]; Char_t AncW[100]; Char_t WarningW[100]; Char_t EndColor[100];

}
using namespace __LoadWatchers__ ;


void GANILLoadWatchers(const Char_t *comp_opt = "g", const Char_t *path_to_agapro = "")
{
//    // to modify to Aclic compilation's options + to force re-compilation, g for debugging
//    CompOpt = comp_opt;

//    // keep path to agapro to set up WatcherConfig.h so that is knows AGAPRO
//    AGAPRO = path_to_agapro;

    BeginLoadWatchers();
    PreLoad();
    LoadWatchers_AGATA();
    LoadWatchers_ANCILLARIES();
    LoadWatchers_MyWatchers();
    LoadSpectraViewer();
    LoadVisuWatchers();

    EndLoadWatchers();
}

void LoadClass(TString cpp_path)
{
    if(!gSystem->IsFileInIncludePath(cpp_path))
    {
        cout<<cpp_path<<" not found, class not loaded."<<endl;
        return;
    }
    else
    {
        TString CompileLine = ".L " + cpp_path + Form("+%s",CompOpt.Data());
        gROOT->ProcessLine(CompileLine.Data());
    }
}

// add a directory containing includes
void AddInclude(TString what_directory)
{
    if(!what_directory.BeginsWith("/"))
    {
        TString CurrentDir = gSystem->pwd();
        CurrentDir += "/";
        what_directory.Prepend(CurrentDir);
    }
    tmp = what_directory;  printf("{Conf} Add %s to the include path \n",tmp.Data());
    tmp.Prepend(" .include ");
    gROOT->ProcessLine(tmp.Data());
}

void SetBasicMacros(TString what_file, TString what_sub_directory)
{
    if ( gSystem->AccessPathName( what_file.Data() ) ) { // does not exist
        cout << "{Conf} A standard " << what_file << " is installed from " << what_sub_directory << "/" << CAMPAIGN  << endl;
        gSystem->CopyFile(Form("%s/%s/%s",what_sub_directory.Data(),CAMPAIGN.Data(),what_file.Data()),what_file.Data());
    }
    
    if(what_file.EndsWith(".sh"))
        gSystem->Exec(Form("chmod u+x %s",what_file.Data()));
}

// called before loading any Watchers
void PreLoad()
{
    sprintf(DefaultW,"  \033[1;34m [*] "); sprintf(MyW,"  \033[1;32m [+] "); sprintf(WarningW,"  \033[1;31m [!] ");  sprintf(AncW,"  \033[1;35m [+] "); sprintf(EndColor,"\033[0m");

    AddInclude("Macros");
    LoadClass("Macros/WatchersUtilities.C");
    gROOT->ProcessLine("WatchersUtilities()");

    LoadClass("Macros/EmulatorControl.C");

    AddInclude("Macros/Visu/");
    LoadClass("Macros/Visu/LoupeOnPad.cpp");
}

void LoadVisuWatchers()
{
    //Visu
    LoadClass("Macros/Visu/WatchersTools.cpp");
}

void LoadSpectraViewer()
{
    AddInclude("./Macros/SpectraViewer/");

    AddInclude("Macros/SpectraViewer/GWRecal");
    LoadClass("Macros/SpectraViewer/GWRecal/FitSpek.cpp");
    LoadClass("Macros/SpectraViewer/GWRecal/ReadSpek.cpp");
    LoadClass("Macros/SpectraViewer/GWRecal/RecalEnergy.cpp");

    LoadClass("Macros/SpectraViewer/FitSpectra.cpp");
    LoadClass("Macros/SpectraViewer/FitFunctions.cpp");
    LoadClass("Macros/SpectraViewer/SpectraViewerWatcher.cpp");
    LoadClass("Macros/SpectraViewer/BaselineWatcher.cpp");
    LoadClass("Macros/SpectraViewer/RawAmpWatcher.cpp");
    LoadClass("Macros/SpectraViewer/SignalWatcher.cpp");

    LoadClass("Macros/SpectraViewer/SpecViewer.C");
}

void BeginLoadWatchers()
{
    // ---> GammaWare PART /////////////////////////
    printf("******************************************************************** \n") ;
    printf("        Configure/Compile/Load Watcher for the GANIL phase \n") ;
    printf("******************************************************************** \n") ;
    
    // to add to ROOT the Gw path to look for macros
    TString tmp, macroPATH;
    
    macroPATH = gROOT->GetMacroPath(); tmp = Gw::Env::GetPath("MacrosPath");
    if ( macroPATH.Contains(tmp.Data()) == false ) {
        printf("{Conf} Add %s to the macros path \n",tmp.Data());
        tmp += ":";
        macroPATH.Prepend(tmp.Data()); gROOT->SetMacroPath(macroPATH.Data());
    }
    
    // add GammaWare include path to ROOT for compilation
    AddInclude(Gw::Env::GetPath("IncludePath"));
    
    // load the different Gw libraries needed
    gSystem->Load("libGWCORE.so");
    gSystem->Load("libGWADF.so");
    gSystem->Load("libGWADFE.so");
    gSystem->Load("libGWTOOLS.so");
    gSystem->Load("libGWPHYSICS.so");

    if ( AGAPRO.Contains("/") ) {
        
        AGAPRO.Append("/include"); printf("{Conf} Add path to AGAPRO includes [%s] to the include path \n",AGAPRO.Data());
        AGAPRO.Prepend(" .include ");
        gROOT->ProcessLine(AGAPRO.Data());
        
        gSystem->Load("libAgaProCommon.so");
        gSystem->Load("libCrystalProducer.so");
        gSystem->Load("libPreprocessingFilter.so");
        gSystem->Load("libTrackingFilter.so");
    }

    // some includes fro watchers
    gSystem->MakeDirectory("./MyWatchers");
    gSystem->MakeDirectory("./Out");

    AddInclude( Form("DefaultWatchers/%s",CAMPAIGN.Data()) );
    AddInclude("./MyWatchers");
    AddInclude("./Macros");

    // depending on ancillary it set WatchersConfig.h
    MFMDIR = gSystem->Getenv("MFMLIB"); VAMOSDIR = gSystem->Getenv("VAMOSLIB"); GRUDIR = gSystem->Getenv("GRULIB");

    std::ofstream fdefs("WatchersConfigNew.h",ios::out | ios::trunc);
    if ( fdefs.is_open() ) {
        
        // AGAPRO Part
        if ( AGAPRO.Contains("/") ) {
            fdefs << "#define HAS_AGAPROCONFIG " << std::endl;
        }
        
        // GANIL PART
        fdefs << "// enable / disable GANIL " << std::endl;
        if ( MFMDIR != "" && !gSystem->AccessPathName(Form("%s/lib/libMFM.so",MFMDIR.Data())) ) { // GANIL/MFM
            fdefs << "#define HAS_GANIL " << std::endl; fdefs << "#define WITH_MFM " << std::endl; HAS_GANIL = true;

            tmp = MFMDIR; tmp+= "/include"; printf("{Conf} Add %s to the include path \n",tmp.Data());
            tmp.Prepend(" .include ");
            gROOT->ProcessLine(tmp.Data());


            if ( VAMOSDIR != ""
                 && !gSystem->AccessPathName(Form("%s/lib/libVamos.so",VAMOSDIR.Data()))
                 && !gSystem->AccessPathName(Form("%s/lib/libGWVamos.so",VAMOSDIR.Data()))
                 //                  && !gSystem->AccessPathName(Form("%s/lib/libVamos.so",isganil_mfm.Data()))
                 ) {
                fdefs << "#define HAS_VAMOS " << std::endl;

                tmp = VAMOSDIR; tmp+= "/include"; printf("{Conf} Add %s to the include path \n",tmp.Data());
                tmp.Prepend(" .include ");
                if(VAMOSDIR!=MFMDIR) gROOT->ProcessLine(tmp.Data());
            }
            else VAMOSDIR = "";
            
            if ( GRUDIR != "" ) {
                fdefs << "#define HAS_GRU " << std::endl;
            }
            else GRUDIR = "";
        }
        else MFMDIR = "";
    }
    fdefs.close();

    std::ifstream fich2("WatchersConfig.h");
    if(!fich2) system("mv WatchersConfigNew.h WatchersConfig.h");
    else if(system("diff WatchersConfigNew.h WatchersConfig.h")) system("mv WatchersConfigNew.h WatchersConfig.h");
    else system("rm WatchersConfigNew.h");

    // basic setup not defined, take the default from Macros/CAMPAIGN
    SetBasicMacros("SetupWatchers.C","Macros");
    SetBasicMacros("OnlineWatchersLLP.C","Macros");
    SetBasicMacros("OnlineWatchersGLP.C","Macros");
    SetBasicMacros("OfflineWatchers.C","Macros");
    SetBasicMacros("ADF_to_Tree.C","Macros");
    //
    SetBasicMacros("SpyLLP.C","Macros");
    SetBasicMacros("SpyGLP.C","Macros");
    SetBasicMacros("RunOffline.C","Macros");
    SetBasicMacros("RunADFToTree.C","Macros");
    SetBasicMacros("StartBatch.sh","Macros");
    SetBasicMacros("StartOfflineWatchers.sh","Macros");
}

void LoadWatchers_MyWatchers()
{
    std::cout <<  MyW << " User's Watchers " <<  EndColor << std::endl;
    std::cout << "|INFO| Place to add personnal Watchers" << std::endl;
    std::cout << "|INFO| 1 - Put your files (Ex: MyW.h and MyW.C) in the MyWatchers Directory " << std::endl;
    std::cout << "|INFO| 2 - Add LoadClass(\"MyWatchers/MyW.C\") just under this line is this GANILLoadWatchers.C Macro and re-start" << std::endl;
    std::cout <<  MyW << " User's Watchers DONE " <<  EndColor << std::endl;
}

// Watchers specific to AGATA
void LoadWatchers_AGATA()
{
    std::cout <<  DefaultW << " AGATA Default Watchers " <<  EndColor << std::endl;

    LoadClass(Form("DefaultWatchers/%s/CanvasVisu.C",CAMPAIGN.Data()));
    LoadClass(Form("DefaultWatchers/%s/ADFWatchers.C",CAMPAIGN.Data()));
    LoadClass(Form("DefaultWatchers/%s/KeyWatchers.C",CAMPAIGN.Data()));
    LoadClass(Form("DefaultWatchers/%s/WatcherClient.C",CAMPAIGN.Data()));
    LoadClass(Form("DefaultWatchers/%s/MetaWatchers.C",CAMPAIGN.Data()));
    LoadClass(Form("DefaultWatchers/%s/PSAWatchers.C",CAMPAIGN.Data()));
    LoadClass(Form("DefaultWatchers/%s/TrackedWatchers.C",CAMPAIGN.Data()));
    LoadClass(Form("DefaultWatchers/%s/EventPSAWatchers.C",CAMPAIGN.Data()));
    LoadClass(Form("DefaultWatchers/%s/CrystalWatchers.C",CAMPAIGN.Data()));
    LoadClass(Form("DefaultWatchers/%s/EventWatchers.C",CAMPAIGN.Data()));
    
    // tree
    LoadClass( Form("DefaultWatchers/%s/ADTree.C",CAMPAIGN.Data()) );

    std::cout <<  DefaultW << " AGATA Default Watchers DONE " <<  EndColor << std::endl;
}

// Watchers specific to GANIL
void LoadWatchers_ANCILLARIES()
{
    std::cout <<  AncW << " Watchers for ancillaries " <<  EndColor << std::endl;

    if ( HAS_GANIL == false ) {
        std::cout <<  AncW << " NO Watchers for ancillaries, install first MFM [MANDATORY] VAMOS / GRU ... to get some " <<  EndColor << std::endl;
        return;
    }
    if ( MFMDIR != "" ) {
        cout << "[Load] libMFM from " << MFMDIR << endl;
        gSystem->Load( "libMFM.so" );
        
//        tmp = MFMDIR; tmp+= "/include"; printf("{Conf} Add %s to the include path \n",tmp.Data());
//        tmp.Prepend(" .include ");
//        gROOT->ProcessLine(tmp.Data());
    }
    if ( VAMOSDIR != "" ) {
        cout << "[Load] libVamos.so and libGWVamos.so from " << VAMOSDIR << endl;
        gSystem->Load( "libVamos.so" );
        gSystem->Load( "libGWVamos.so" );
        
//        tmp = VAMOSDIR; tmp+= "/include"; printf("{Conf} Add %s to the include path \n",tmp.Data());
//        tmp.Prepend(" .include ");
//        gROOT->ProcessLine(tmp.Data());
        
        tmp = gSystem->Getenv("ANALYSIS_AGATA");
        if ( !(tmp == "") ) {
            printf("{Conf} ANALYSIS_AGATA found to be %s \n",tmp.Data());
        }
        else {
            printf("{Conf} Set ANALYSIS_AGATA to ./ConfVAMOS \n"); gSystem->Setenv("ANALYSIS_AGATA","./ConfVAMOS");
        }
    }
    if ( GRUDIR != "" ) {
        cout << "- Load libGRU.so from " << GRUDIR.Data() << endl;
        gSystem->Load( Form("%s/lib/libGRU.so",GRUDIR.Data()) );
        tmp = GRUDIR; tmp+= "/include"; printf("- Add %s to the include path \n",tmp.Data());
        tmp.Prepend(" .include ");
        gROOT->ProcessLine(tmp.Data());
    }

    // to be changed in DefaultGANIL
    LoadClass(Form("DefaultWatchers/%s/GANILWatchers.C",CAMPAIGN.Data()));
    std::cout <<  AncW << " Watchers for ancillaries DONE" <<  EndColor << std::endl;
}

void CheckConf(TString what_conf)
{
    if ( what_conf == "ADF.conf" ) {
        //
        TString adf_path = gSystem->Getenv("ADF_CONF_PATH");
        //
        if ( adf_path == "" ) { // the ADF_CONF_PATH is not set, try the current directory. If no ADF.conf file, load a default from server
            Bool_t ok = false;
            //
            if ( !gSystem->AccessPathName("./ADF.conf") ) { // current directory
                ok = true;
            }
            else {
                // try and downlaod into a temporary directory
                TString tmp_dir = gSystem->TempDirectory();
                std::cout << WarningW << "Cannot find ADF.conf ... try and install a default one from internet, make sure it fullfils your needs " << EndColor << std::endl;
                gSystem->Exec(Form("svn --quiet checkout svn+ssh://anonsvn@anonsvn.in2p3.fr/agata/conf/watchers/ %s",tmp_dir.Data()));
                if ( gSystem->CopyFile(Form("%s/ADF.conf",tmp_dir.Data()),"./ADF.conf") == 0 )
                    ok = true;
            }
            if ( ok ) { // does not exist in the current directory
                adf_path = gSystem->Getenv("PWD");
                
            }
        }
        if ( adf_path == "" ) {
            std::cout << WarningW << " ADF_CONF_PATH not set !" << EndColor << std::endl;
        }
        else {
            gSystem->Setenv("ADF_CONF_PATH",adf_path.Data());
            printf("\n\t{Conf}\tADF_CONF_PATH has been set to %s \n\n",adf_path.Data());
        }
    }
    if ( what_conf == "CrystalPositionLookUpTable.dat" ) {
        //
        Bool_t ok = false;
        if ( !gSystem->AccessPathName("./CrystalPositionLookUpTable.dat") ) { // current directory
            ok = true;
        }
        else {
            // try and downlaod into a temporary directory
            TString tmp_dir = gSystem->TempDirectory();
            gSystem->Exec(Form("svn --quiet checkout svn+ssh://anonsvn@anonsvn.in2p3.fr/agata/conf/watchers/ %s",tmp_dir.Data()));
            if ( gSystem->CopyFile(Form("%s/CrystalPositionsLookUpTableGANIL.dat",tmp_dir.Data()),"./CrystalPositionLookUpTable.dat") == 0 ) {
                std::cout <<  WarningW << "CrystalPositionLookUpTable.dat was not there ... a default one from internet has been installed, make sure it fullfils your needs! " << EndColor << std::endl;;
                ok = true;
            }
        }
        if ( !ok ) {
            std::cout << WarningW << "Mapping of AGATA Ge Crystal, CrystalPositionLookUpTable.dat, not found !" << EndColor << std::endl;
        }
    }

    if ( (what_conf == "TimeChecks.conf") && gSystem->AccessPathName( what_conf.Data() ) ) { // does not exist
        cout << "{Conf} A standard " << what_conf << " is installed from Conf folder" << endl;
        gSystem->CopyFile("Conf/TimeChecks.conf",what_conf.Data());
    }

}

void EndLoadWatchers()
{
    // Gives some command that can be run
    cout << endl << "|INFO| ... informations ... messages ... help ... for Online/Quasi Online Analysis |" << endl;
    cout << "|INFO|" << endl;
    cout << "|INFO|\tTo start online (Local Level) Watchers : " << endl;
    cout << "|INFO|\t.L OnlineWatchersLLP.C+ " << endl;
    cout << "|INFO|\tOnlineWatchersLLP(0x0,0x0) or OnlineWatchersLLP(new TFile(\"MySpectra.root\",\"UPDATE\"),new TFile(\"MyTagSpectra.root\",\"UPDATE\"))" << endl;
    cout << "|INFO|\tTo start online (Global Level) Watchers : " << endl;
    cout << "|INFO|\t.L OnlineWatchersGLP.C+ " << endl;
    cout << "|INFO|\tOnlineWatchersGLP() or OnlineWatchersGLP(new TFile(\"MySpectra.root\",\"UPDATE\"),new TFile(\"MyTagSpectra.root\",\"UPDATE\"))" << endl;
    cout << "|INFO|\tThen start the watching from the ROOT Browser " << endl;
    cout << "|INFO|" << endl;
    cout << "|INFO|\tTo start offline Watchers : " << endl;
    cout << "|INFO|\t\t1 - Configure OfflineWatcher.C (it could be a copy of of the one in DefaultWatchers)" << endl;
    cout << "|INFO|\t\t2 - Compile/Run the Watchers with : " << endl;
    cout << "|INFO|\t\t.L OfflineWatchers.C+" << endl;
    cout << "|INFO|\t\tOfflineWatchers() or OfflineWatchers(new TFile(\"MySpectra.root\",\"UPDATE\"))" << endl;
    cout << "|INFO|" << endl;
    cout << "|INFO|\tTo start Actor Spectra Watchers : " << endl;
    cout << "|INFO|\t\t1 -  For different files from a run:"<<endl;
    cout << "|INFO|\t\t     Import(TString Incl=\"*\", TString Excl=\"*.samp\", TString DefaultPath=\"\");" <<endl;
    cout << "|INFO|\t\t     ex: Import(\"*\",\"*.samp\",\"\")" << endl;
    cout << "|INFO|\t\t2 -  For a single spectrum file:"<<endl;
    cout << "|INFO|\t\t     ImportFile(TString DefaultPath="", Double_t DefGain=1);" <<endl;
    cout << "|INFO|\t\t     ex: ImportFile(\"Path/Containing/Spectrum/File\",\"Gain if necessary\")" << endl;
    cout << "|INFO|" << endl;
    cout << "|INFO| ... informations ... messages ... help ... for Online/Quasi Online Analysis |" << endl;

    // check whether or not ADF_CONF_PATH has been set !
    CheckConf("ADF.conf");
    CheckConf("CrystalPositionLookUpTable.dat");
    CheckConf("TimeChecks.conf");

    BuildFolders();

}

void BuildFolders()
{
    // start a ROOT TBrowser
    gROOT->ProcessLine("TFolder *TaskFolder = (TFolder*)gROOT->GetRootFolder()->FindObject(\"Tasks\");");
    gROOT->ProcessLine("TBrowser *browser = new TBrowser(\"Browser\",TaskFolder,\"Welcome in the wonderful world of Gammaware watchers, have fun !!!\");");

    gROOT->ProcessLine("TFolder *SpectraViewerFolder  = (TFolder*)gROOT->GetRootFolder()->FindObject(\"SpectraViewer\");");
    gROOT->ProcessLine("if (SpectraViewerFolder) browser->BrowseObject(SpectraViewerFolder);");

    gROOT->ProcessLine("TFolder *GwWatchersFolder  = (TFolder*)gROOT->GetRootFolder()->FindObject(\"GwWatchers\");");
    gROOT->ProcessLine("if(GwWatchersFolder) browser->BrowseObject(GwWatchersFolder);");

    gROOT->ProcessLine("gROOT->GetRootFolder()->AddFolder(\"Tools\",\"Tools\");");
    gROOT->ProcessLine("TFolder *f = (TFolder*)gROOT->GetRootFolder()->FindObject(\"Tools\");");

    gROOT->ProcessLine("ManipConfig *WManipConfig= new ManipConfig(\"GlobalView\",\"GlobalView\");");
    gROOT->ProcessLine("f->Add(WManipConfig)");

    gROOT->ProcessLine("Gw::GSPlayerTUI *SpectrumPlayer = new Gw::GSPlayerTUI(\"SpectrumPlayer\",\"SpectrumPlayer\");");
    gROOT->ProcessLine("f->Add(SpectrumPlayer);");

    gROOT->ProcessLine("Collector *theCollector = new Collector(\"SpectraCollector\",\"SpectraCollector\");");
    gROOT->ProcessLine("f->Add(theCollector);");

    gROOT->ProcessLine("WatchersRefresh *WRefresh = new WatchersRefresh(\"AutoRefresh\",\"AutoRefresh\");");
    gROOT->ProcessLine("f->Add(WRefresh);");

    gROOT->ProcessLine("browser->Add(f);");

    gROOT->ProcessLine("if ( browser ) browser->Draw();");
}

void CleanWatchers()
{
    CleanDir(Form("DefaultWatchers/%s",CAMPAIGN.Data()));
    CleanDir(".");
    CleanDir("MyWatchers");
    CleanDir("Macros");
    CleanDir("Macros/Visu");
    CleanDir("Macros/SpectraViewer");
    CleanDir("Macros/SpectraViewer/GWRecal");
}

void CleanDir(TString Dir)
{
    gSystem->Exec(Form("rm -rf %s/*_C.so %s/*_C.d %s/*.o %s/*_cpp.so %s/*_cpp.d %s/*.pcm",
                       Dir.Data(),Dir.Data(),Dir.Data(),Dir.Data(),Dir.Data(),Dir.Data() ));
}

void CleanSetup()
{
    gSystem->Rename("SetupWatchers.C","MyWatchers/SetupWatchers.backup");
    gSystem->Rename("OnlineWatchersLLP.C","MyWatchers/OnlineWatchersLLP.backup");
    gSystem->Rename("OnlineWatchersGLP.C","MyWatchers/OnlineWatchersGLP.backup");
    gSystem->Rename("OfflineWatchers.C","MyWatchers/OfflineWatchers.backup");
    gSystem->Rename("ADF_To_Tree.C","MyWatchers/ADF_To_Tree.backup");
    
    gSystem->Rename("ADF_to_Tree.C","MyWatchers/ADF_to_Tree.backup");
    gSystem->Rename("SpyLLP.C","MyWatchers/SpyLLP.backup");
    gSystem->Rename("SpyGLP.C","MyWatchers/SpyGLP.backup");
    gSystem->Rename("RunOffline.C","MyWatchers/RunOffline.backup");
    gSystem->Rename("RunADFToTree.C","MyWatchers/RunADFToTree.backup");
    gSystem->Rename("StartBatch.sh","MyWatchers/StartBatch.sh.backup");
}