adf/Macros/EmulatorControl.C

Go to the documentation of this file.

#include "EmulatorControl.h"
#include "FrameDispatcher.h"

// root/system includes
#include "TRegexp.h"
#include "TSystem.h"
#include "TSystemDirectory.h"

#include <fstream>

using namespace Gw;

//ClassImp(EmulatorControl);

void EmulatorControl::Run(UInt_t max_loop)
{
    if ( fIsRunning ) {// already in loop
        fBashColor->SetWarningOut();
        std::cout << "Emulator already running " << std::endl;
        fBashColor->ResetColor();
        return;
    }
    fIsRunning = true; fNbLoop = max_loop;
    
    fTimer->SetObject(this);
    fTimer->Start(20, kTRUE);
}

void EmulatorControl::Stop()
{
    if ( !fIsRunning ) {// already stopped
        //        fBashColor->SetWarningOut();
        //        std::cout << "Emulator is not running " << std::endl;
        //        fBashColor->ResetColor();
        return;
    }
    else
    {
        fIsRunning = false;
        fTimer->SetObject(this);
        fTimer->Stop();
    }
}

void EmulatorControl::Destroy()
{
    delete fEmulator;
}

void EmulatorControl::Print(Option_t * /*option*/) const
{
    fBashColor->SetInfoOut();
    
    std::cout<<"Watchers properties:"<<std::endl;
    
    FrameDispatcher *fd =
    dynamic_cast<FrameDispatcher *> (fEmulator->GetBaseConsumer()) ;
    
    const TList *ListOfWatchers = fd->GetListOfWatchers();
    TIter iter(ListOfWatchers);
    TObject *o;
    
    while( (o = iter.Next()) )
    {
        o->Print();
    }
    
    fBashColor->ResetColor();
}


void EmulatorControl::Save(Option_t *opt)
{
    fEmulator->GetBaseConsumer()->GetFrameIO().Print();
    
    FrameDispatcher *fd =
    dynamic_cast<FrameDispatcher *> (fEmulator->GetBaseConsumer()) ;
    if ( fd )
        fd->Snapshot(opt);
}

Bool_t EmulatorControl::HandleTimer(TTimer* /*timer*/)
{
    if ( fEmulator )
        fEmulator->Run(fNbLoop);
    return true;
}

TString BaseEmulatorChain::DoROOTAFPConf(Int_t which_run, const char *path, const char *which_adf_data, const char *run_pat, Option_t *opt_adf_pattern, const char *tmp_rootafp_filename)
{
    TString result = "", t_path = path, path_in_exp = which_adf_data, opt = opt_adf_pattern, run_name_pattern=run_pat; Bool_t ok_dir = false;
    
    if ( !t_path.EndsWith("/") )
        t_path += "/";
    
    // First it looks at the list of sub-directory in path to search from one containing the run number
    TString dir_name = ""; TSystemDirectory dir; dir.SetDirectory(t_path.Data());
    //
    TList *list = dir.GetListOfFiles();
    TIter iter(list);
    TObject *entry;
    //
    while ( (entry = iter()) )
    {
        if ( entry->InheritsFrom("TSystemDirectory") )
        {
            
            TString fname = entry->GetName();
            if ( fname.Contains( Form("%s%4.4d",run_pat,which_run) ) ) {
                dir_name = t_path.Data();
                dir_name += entry->GetName();
                if ( path_in_exp.Sizeof() ) {
                    if ( !path_in_exp.BeginsWith("/") )
                        dir_name += "/";
                    dir_name += which_adf_data;
                    if ( !path_in_exp.EndsWith("/") )
                        dir_name += "/";
                }
                result = entry->GetName();
                ok_dir = true;
                
                break;
            }
        }
    }
    if ( !ok_dir ) {
        std::cout << " **** !! **** Run # " << which_run << " has not been found in path " << path << std::endl;
        return result;
    }
    else {
        if ( !dir_name.EndsWith("/") )
            dir_name += "/";
        std::cout << " Run # " << which_run << " has been found in path " << path << " - full directory is " << dir_name <<  std::endl;
    }
    
    TSystemDirectory dir_run; dir_run.SetDirectory(dir_name); TList list_of_final_file;
    //
    list = dir_run.GetListOfFiles();
    if ( list == 0x0 ) {
        result = "";
        std::cout << dir_name <<  " Is Empty " << std::endl;
        return result; // no files with such a run number
    }
    list->Sort();
    TIter iter_file(list); // start collecting .adf file
    //
    while ( (entry = iter_file()) )
    {
        TString fname = entry->GetName();
        
        Bool_t wildcard = false;
        if ( opt.Contains("*") )
            wildcard = true;
        TRegexp all("*",kTRUE), pattern(opt.Data(),wildcard);
        
        if ( pattern.Status() != TRegexp::kOK )
        {
            if ( gDebug > 0 )
                std::cerr << "pattern [*] intead of " << opt.Data()<< std::endl;
            pattern = all;
        }
        else
        {
            if ( gDebug > 0 ) std::cerr << "pattern " << opt.Data() << std::endl ;
        }
        if ( entry->InheritsFrom("TSystemFile") )
        {
            if ( fname.Contains( pattern ) ) {
                list_of_final_file.Add( new TNamed(dir_name.Data(),fname.Data()) );
                std::cout << " + ADD ADF " << fname.Data() << " file to the list of files to be read " <<  std::endl;
            }
        }
    }
    if ( list_of_final_file.GetEntries() ) {
        std::ofstream outputfile(tmp_rootafp_filename);
        std::cout << " A new file, " << tmp_rootafp_filename << ", suitable to configure the RootAFP producer, has been created " << std::endl;
        for ( Int_t i = 0; i < list_of_final_file.GetSize(); i++ )
        {
            outputfile << "l "  << list_of_final_file.At(i)->GetName() << list_of_final_file.At(i)->GetTitle() << std::endl;
        }
        outputfile.close();
    }
    else result = "";
    
    RunNumber = which_run; RunDir = result; // keep it
    
    return result;
}

Bool_t BaseEmulatorChain::Init(const Char_t *rootafpconf)
{
    TString RootAFPConf = rootafpconf; Bool_t is_default_rootafp = false;
    //
    if ( RootAFPConf == "" ) { // just use standart RootAFP.conf file
        is_default_rootafp = true;
    }
    else { // use the one given in argument ... test if it exists !
        if ( gSystem->AccessPathName(rootafpconf)  ) {
            std::cout << " File " << rootafpconf << " does not exist ! - Cannot proceed " << std::endl;
            return false;
        }
        // then keep current RootAFP and copy this one into RootAFP.conf just the time to initiate the emulator
        gSystem->Rename("RootAFP.conf",".RootAFP.conf.keep"); gSystem->CopyFile(rootafpconf,"RootAFP.conf");
    }
    
    // chain a producer and a FrameDispacher to which Watchers are attached
    if ( ! this->Init() ) {
        if ( !is_default_rootafp )
            gSystem->Rename(".RootAFP.conf.keep","RootAFP.conf"); std::cout << "Cannot Init emulator" << std::endl;
        return false;
    }
    else {
        if ( !is_default_rootafp )
            gSystem->Rename(".RootAFP.conf.keep","RootAFP.conf");
        // emulator->GetBaseConsumer()->SetName();
    }
    
    return true;
}

Bool_t BaseEmulatorChain::Init(Int_t which_run, const char *which_experiment, const char *which_adf_data, const char *run_name_pattern, Option_t *opt_adf_pattern)
{
    TString result = BaseEmulatorChain::DoROOTAFPConf(which_run,which_experiment,which_adf_data,run_name_pattern,opt_adf_pattern,".RootAFP.conf.tmp");
    if ( result == ""  ) {
        return false;
    }
    return Init(".RootAFP.conf.tmp");
}