LoadWatchers.C

Go to the documentation of this file.

void LoadWatchers_AGATA();
void LoadWatchers_Legnaro();
void LoadWatchers_GSI();
void BeginLoadWatchers();
void EndLoadWatchers();

namespace __LoadWatchers__ {
        // to modify to Aclic compilation's options 
        // .L toto.C+[CompOpt] with CompOpt = "" or "+" or "+g"         
        const Char_t *CompOpt = "";
        
        TString tmp;
        
        // path to agapro
        TString AGAPRO;
}
using namespace __LoadWatchers__ ;


void LoadWatchers(const Char_t *path_to_agapro = "") 
{ 
        tmp = CompOpt;
        if ( tmp.Contains("g")  ) {
                gSystem->SetAclicMode(TSystem::kDebug);
        }
        
        // keep path to agapro to set up WatcherConfig.h so that is knows AGAPRO
        AGAPRO = path_to_agapro;
        
        BeginLoadWatchers();
        
        tmp = Form(".L EmulatorControl.C+%s",CompOpt);
        gROOT->ProcessLine(tmp.Data()); 
        
        LoadWatchers_AGATA();
        LoadWatchers_Legnaro();
        LoadWatchers_GSI();
        
        // Special to watchers 
        tmp = Form(".L MyWatchers/MyTree.C+%s",CompOpt);
        gROOT->ProcessLine(tmp.Data()); 
        
        EndLoadWatchers();
}

#include <fstream>

void BeginLoadWatchers()
{
        // ---> GammaWare PART /////////////////////////
        printf("******************************************************************** \n") ;
        printf("                    Messages from LoadWatchers.C \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("- 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
        tmp = Gw::Env::GetPath("IncludePath");  printf("- Add %s to the include path \n",tmp.Data());
        tmp.Prepend(" .include "); 
        gROOT->ProcessLine(tmp.Data());
        
        // 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("- 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");
        }
        
        
        // compile and load the different watchers
        tmp = "./MyWatchers" ;  printf("- Add %s to the include path \n",tmp.Data());
        tmp.Prepend(" .include ");  
        gROOT->ProcessLine(tmp.Data());
        tmp = "./DefaultWatchers" ;  printf("- Add %s to the include path \n",tmp.Data());
        tmp.Prepend(" .include ");  
        gROOT->ProcessLine(tmp.Data());
        
        // basic setup not defined, take the default 
        if ( gSystem->AccessPathName("./SetupWatchers.C") ) { // does not exist
                cout << "- Standard configuration (Default setup, SetupWatchers.C) installed " << endl;
                //
                gSystem->CopyFile("Macros/SetupWatchers.C","./SetupWatchers.C");        
        }
        // depending on ancillary it set WatchersConfig.h
        TString isprisma = gSystem->Getenv("PRISMA_PREPROC"), isprespec = gSystem->Getenv("PRESPEC"), isgo4 = gSystem->Getenv("GOSYS");
        std::ofstream fdefs("WatchersConfig.h",ios::out | ios::trunc);
        if ( fdefs.is_open() ) {
                fdefs << "// enable / disable prisma " << std::endl;                    
                if ( isprisma == "" ) { // no prisma
                        fdefs << "//" ;
                }
                fdefs << "#define HAS_PRISMA " << std::endl;
                
                fdefs << "// enable / disable prespec " << std::endl;                   
                if ( isprespec == "" ) {
                        fdefs << "//" ;                         
                }
                fdefs << "#define HAS_PRESPEC " << std::endl;
                
                fdefs << "// enable / disable go4 " << std::endl;                       
                if ( isgo4 == "" ) {
                        fdefs << "//" ;                         
                }
                fdefs << "#define HAS_GO4 " << std::endl;
                
                if ( AGAPRO.Contains("/") ) {
                        fdefs << "#define HAS_AGAPROCONFIG " << std::endl;
                }
        }
        // basic setup not defined, take the default 
        if ( gSystem->AccessPathName("./OnlineWatchersLLP.C") ) { // does not exist
                cout << "- Customisable default OnlineWatchersLLP.C installed " << endl;
                gSystem->CopyFile("Macros/OnlineWatchersLLP.C","./OnlineWatchersLLP.C");        
        }
        // basic setup not defined, take the default 
        if ( gSystem->AccessPathName("./OnlineWatchersGLP.C") ) { // does not exist
                cout << "- Customisable default OnlineWatchersGLP.C installed " << endl;
                gSystem->CopyFile("Macros/OnlineWatchersGLP.C","./OnlineWatchersGLP.C");        
        }
        // basic setup not defined, take the default 
        if ( gSystem->AccessPathName("./OfflineWatchers.C") ) { // does not exist
                cout << "- Customisable default OfflineWatchers.C installed" << endl;
                gSystem->CopyFile("Macros/OfflineWatchers.C","./OfflineWatchers.C");    
        }
        
        // Add personnal watchers in MyWatchers
        if ( gSystem->AccessPathName("MyWatchers") ) { // does not exist
                cout << "- Add personnal customisable watchers " << endl;        
                gSystem->mkdir("./MyWatchers");
                gSystem->CopyFile("Macros/MyTree.h","MyWatchers/MyTree.h");
                gSystem->CopyFile("Macros/MyTree.C","MyWatchers/MyTree.C");
        }       
}

void EndLoadWatchers()
{
        // Gives some command that can be run 
        cout << endl;
        cout << " To start online (Local Level) Watchers : " << endl;
        cout << "    .L OnlineWatchersLLP.C+ " << endl; 
        cout << "   - to watch only one selected actor " << endl;
        cout << "    OnlineWatchersLLP() or OnlineWatchersLLP(new TFile(\"MySpectra.root\",\"UPDATE\"),new TFile(\"MyTagSpectra.root\",\"UPDATE\"))" << endl;
        cout << "   - to watch simultaneously all the actors  " << endl;        
        cout << "    OnlineWatchersLLP(0x0,0x0,true) or OnlineWatchersLLP(new TFile(\"MySpectra.root\",\"UPDATE\"),new TFile(\"MyTagSpectra.root\",\"UPDATE\"),true)" << endl;
        cout << " To start online (Global Level) Watchers : " << endl;
        cout << "    .L OnlineWatchersGLP.C+ " << endl;         
        cout << "    OnlineWatchersGLP() or OnlineWatchersGLP(new TFile(\"MySpectra.root\",\"UPDATE\"),new TFile(\"MyTagSpectra.root\",\"UPDATE\"))" << endl;   
        cout << " Then start the watching from the ROOT Browser " << endl << endl;
        cout << " To start offline Watchers : " << endl; 
        cout << "   1 - Configure OfflineWatcher.C (it could be a copy of of the one in DefaultWatchers)" << endl; 
        cout << "   2 - Compile/Run the Watchers with : " << endl;  
        cout << "    .L OfflineWatchers.C+" << endl;
        cout << "    OfflineWatchers() or OfflineWatchers(new TFile(\"MySpectra.root\",\"UPDATE\"))" << endl;
        cout << endl;
        
        // check whether or not ADF_CONF_PATH has been set !
        TString adf_path = gSystem->Getenv("ADF_CONF_PATH");
        if ( adf_path == "" ) {
                if ( ! gSystem->AccessPathName("./ADF.conf") ) { // does exist
                        // get the current directory
                        TString pwd_path = gSystem->Getenv("PWD");
                        // set ADF_CONF_PATH to the current directory
                        gSystem->Setenv("ADF_CONF_PATH",pwd_path.Data()); 
                        
                        printf("\n [Info] ADF_CONF_PATH has been set to %s \n\n ",pwd_path.Data());
                } 
                else 
                        cout << "\n ** [WARNING] ** , ADF_CONF_PATH not set ! " << endl << endl;                
        }
        else printf("\n [Info] ADF_CONF_PATH is %s \n\n ",adf_path.Data());
        
        // start a ROOT TBrowser 
        TBrowser *b = new TBrowser();   
}

void LoadWatchers_AGATA()
{
        // Load the watchers    
        tmp = Form(".L DefaultWatchers/ADFWatchers.C+%s",CompOpt);
        gROOT->ProcessLine(tmp.Data());
        tmp = Form(".L DefaultWatchers/WatcherClient.C+%s",CompOpt);
        gROOT->ProcessLine(tmp.Data());
        tmp = Form(".L DefaultWatchers/MetaWatchers.C+%s",CompOpt);
        gROOT->ProcessLine(tmp.Data());
        tmp = Form(".L DefaultWatchers/TrackedWatchers.C+%s",CompOpt);
        gROOT->ProcessLine(tmp.Data());
        tmp = Form(".L DefaultWatchers/EventPSAWatchers.C+%s",CompOpt); 
        gROOT->ProcessLine(tmp.Data());
        tmp = Form(".L DefaultWatchers/PSAWatchers.C+%s",CompOpt);      
        gROOT->ProcessLine(tmp.Data());
        tmp = Form(".L DefaultWatchers/CrystalWatchers.C+%s",CompOpt);  
        gROOT->ProcessLine(tmp.Data());
        tmp = Form(".L DefaultWatchers/RancLegnaroWatchers.C+%s",CompOpt);      
        gROOT->ProcessLine(tmp.Data());
        tmp = Form(".L DefaultWatchers/EventWatchers.C+%s",CompOpt);    
        gROOT->ProcessLine(tmp.Data()); 
        tmp = Form(".L DefaultWatchers/DanteWatchers.C+%s",CompOpt);    
        gROOT->ProcessLine(tmp.Data());
        tmp = Form(".L DefaultWatchers/LLaBr3Watchers.C+%s",CompOpt);   
        gROOT->ProcessLine(tmp.Data());
}

void LoadWatchers_Legnaro()
{
        // check if PRISMA_PREPROC is defined
        TString prisma = gSystem->Getenv("PRISMA_PREPROC");
        if ( prisma == "" ) {
                return;
        }
        
        // Directory where are the includes of the ancillary part for compilation
        tmp = prisma + "/src/lib_prisma/include/"; printf("- Add %s to the include path \n",tmp.Data());
        tmp.Prepend(" .include "); 
        gROOT->ProcessLine(tmp.Data());
        
        // ---> the prisma library
        gSystem->Load( Form("%s/lib/libPRISMA.so",prisma.Data()) );
        
        // ---> Compile and load the watchers for PRISMA
        if ( gSystem->AccessPathName("MyWatchers/PrismaWatchers.h") )
                gSystem->CopyFile("Macros/PrismaWatchers.h","MyWatchers/PrismaWatchers.h");
        if ( gSystem->AccessPathName("MyWatchers/PrismaWatchers.C") )
                gSystem->CopyFile("Macros/PrismaWatchers.C","MyWatchers/PrismaWatchers.C");
        
        tmp = Form(".L MyWatchers/PrismaWatchers.C+%s",CompOpt);   
        gROOT->ProcessLine(tmp.Data()); 
}

void LoadWatchers_GSI()
{
        // check prespec is defined
        TString prespec = gSystem->Getenv("PRESPEC"), go4 = gSystem->Getenv("GOSYS"), path_to_libs;
        if ( prespec == "" ) {
        // to be done : check id libs and includes exists in case of agapro
        if ( AGAPRO.Contains("/") ) {
            prespec = AGAPRO; path_to_libs = AGAPRO;
        }
        else return;
        }
    else {
        // manual configuration
        tmp = CompOpt;
        if ( tmp.Contains("g")  ) {
            path_to_libs = Form("%s/debug/lib/",prespec.Data());
        }
        else {
            path_to_libs = Form("%s/release/lib/",prespec.Data());
        }
    }
        
        // make sure some GSI Watchers are in MyWatchers
        if ( gSystem->AccessPathName("MyWatchers/GSIWatchers.h") )
                gSystem->CopyFile("Macros/GSIWatchers.h","MyWatchers/GSIWatchers.h");
        if ( gSystem->AccessPathName("MyWatchers/GSIWatchers.C") )
                gSystem->CopyFile("Macros/GSIWatchers.C","MyWatchers/GSIWatchers.C");
        
        if ( gSystem->AccessPathName("MyWatchers/GSIPrespecWatchers.h") )
                gSystem->CopyFile("Macros/GSIPrespecWatchers.h","MyWatchers/GSIPrespecWatchers.h");     
        if ( gSystem->AccessPathName("MyWatchers/GSIPrespecWatchers.C") )
                gSystem->CopyFile("Macros/GSIPrespecWatchers.C","MyWatchers/GSIPrespecWatchers.C");
        
        if ( gSystem->AccessPathName("MyWatchers/GSIGO4Watchers.h") )
                gSystem->CopyFile("Macros/GSIGO4Watchers.h","MyWatchers/GSIGO4Watchers.h");     
        if ( gSystem->AccessPathName("MyWatchers/GSIGO4Watchers.C") )
                gSystem->CopyFile("Macros/GSIGO4Watchers.C","MyWatchers/GSIGO4Watchers.C");
        
        // external includes / define / libraries       
        tmp = Form("-I%s",prespec.Data());
        gSystem->AddIncludePath(tmp.Data());  //To include Prespec path
        tmp = Form("-I%s/eventapiV50",prespec.Data());     
        gSystem->AddIncludePath(tmp.Data());  //To include Go4 path
        
    tmp = Form("%s/libgsievt.so",path_to_libs.Data());
    gSystem->Load(tmp.Data()) ;
    tmp = Form("%s/lib_prespec.so",path_to_libs.Data());
    gSystem->Load(tmp.Data()) ;
        
        // ---> Compile and load the watchers for GSI   
        tmp = Form(".L MyWatchers/GSIWatchers.C+%s",CompOpt);
        gROOT->ProcessLine(tmp.Data()); 
        //
        if ( go4 == "" ) {
                tmp = Form(".L MyWatchers/GSIPrespecWatchers.C+%s",CompOpt);
                gROOT->ProcessLine(tmp.Data());                 
        }
        else {
                std::cout << "GO4 Watchers not yet defined ! " << std::endl; 
        }
        
}