LoadStogsWatchers.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 BeginLoadWatchers();
void PreLoad();
void LoadWatchers_AGATA();
void LoadWatchers_ANCILLARIES();
void EndLoadWatchers();
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("");

TString WatchersPath = "../../adf";

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

}
using namespace __LoadWatchers__ ;


void LoadStogsWatchers(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();

    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());
}

// 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");

    LoadClass(Form("%s/Macros/WatchersUtilities.C",WatchersPath.Data()));
    LoadClass(Form("%s/EmulatorControl.C",WatchersPath.Data()));

    AddInclude(WatchersPath);
    AddInclude("../");
    LoadClass("../SToGS_BaseROOTEvents.C");

    AddInclude("../producer/");
    LoadClass("../producer/StogsAFP.cpp");

    AddInclude(Form("%s/Macros/Visu/",WatchersPath.Data()));
    LoadClass(Form("%s/Macros/Visu/LoupeOnPad.cpp",WatchersPath.Data()));
}

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");
    
    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("./Out");

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

    // 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");
}

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

    LoadClass(Form("%s/DefaultWatchers/%s/CanvasVisu.C",WatchersPath.Data(),CAMPAIGN.Data()));
    LoadClass(Form("%s/DefaultWatchers/%s/ADFWatchers.C",WatchersPath.Data(),CAMPAIGN.Data()));
    LoadClass(Form("%s/DefaultWatchers/%s/KeyWatchers.C",WatchersPath.Data(),CAMPAIGN.Data()));
    LoadClass(Form("%s/DefaultWatchers/%s/WatcherClient.C",WatchersPath.Data(),CAMPAIGN.Data()));
    LoadClass(Form("%s/DefaultWatchers/%s/MetaWatchers.C",WatchersPath.Data(),CAMPAIGN.Data()));
    LoadClass(Form("%s/DefaultWatchers/%s/PSAWatchers.C",WatchersPath.Data(),CAMPAIGN.Data()));
    LoadClass(Form("%s/DefaultWatchers/%s/TrackedWatchers.C",WatchersPath.Data(),CAMPAIGN.Data()));
    LoadClass(Form("%s/DefaultWatchers/%s/EventPSAWatchers.C",WatchersPath.Data(),CAMPAIGN.Data()));
    LoadClass(Form("%s/DefaultWatchers/%s/CrystalWatchers.C",WatchersPath.Data(),CAMPAIGN.Data()));
    LoadClass(Form("%s/DefaultWatchers/%s/EventWatchers.C",WatchersPath.Data(),CAMPAIGN.Data()));
    
    // tree
    LoadClass( Form("%s/DefaultWatchers/%s/ADTree.C",WatchersPath.Data(),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("%s/DefaultWatchers/%s/GANILWatchers.C",WatchersPath.Data(),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;
        }
    }
}

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 stogs Watchers : " << endl;
    cout << "|INFO|\t\t1 - Configure StogsWatcher.C" << endl;
    cout << "|INFO|\t\t2 - Compile/Run the Watchers with : " << endl;
    cout << "|INFO|\t\t.L StogsWatchers.C+" << endl;
    cout << "|INFO|StogsWatchers() or StogsWatcher(new TFile(\"MySpectra.root\",\"UPDATE\"))" << endl;
    cout << "|INFO|" << endl;

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

    // start a ROOT TBrowser
    TFolder *TaskFolder =
            (TFolder*)gROOT->GetRootFolder()->FindObject("Tasks");
    TBrowser *browser = new TBrowser("Browser",TaskFolder,"Welcome in the wonderful world of Gammaware watchers, have fun !!!");
    
    TFolder *SpectraViewerFolder  = (TFolder*)gROOT->GetRootFolder()->FindObject("SpectraViewer");
    if (SpectraViewerFolder)
        browser->BrowseObject(SpectraViewerFolder);
    TFolder *GwWatchersFolder  = (TFolder*)gROOT->GetRootFolder()->FindObject("GwWatchers");
    if(GwWatchersFolder)
        browser->BrowseObject(GwWatchersFolder);
    
    if ( browser )
        browser->Draw();
}


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

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() ));
}