STEER/TFndGeb2hdtMan.cxx

// @(#)fROOT/STEER:$Name:  $:$Id: TFndGeb2hdtMan.cxx,v 1.77 2007/09/24 07:32:41 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2006/06/05

#include "TFndGeb2hdtMan.h"
#include "TFndGeb2hdtGUI.h"

  ClassImp(TFndGeb2hdtMan)


//_____________________________
TFndGeb2hdtMan::TFndGeb2hdtMan():
 fRun(),fDebug(),
 fMsqlHost(),fDataPath(),fFileName(),fNevents(),fGebIp(),
 fStartTime(),fStopTime(),fOnlFlg(),fConsumControlFile(),
 fTimeLimit(),fTimedOut(),fUpdateEvGap(),fUpdatingProd(),
 fCurEv(),fLastUpdEv(),fRate(),fExitVal(),fManStop(),fPaused(),
 fHdtRootFile(),
 fMonSaveThread(),
 fConfFileRead(),
 fHdtTree(),fMustSaveHdt(kTRUE)
{
  // the default constructor shall not be used by standard users

  fRun = new TFndRun();
}

//_____________________________
// TFndGeb2hdtMan::TFndGeb2hdtMan(TString msqlhost,TString fpth,TString fnam,Int_t nevts,Int_t gebip):
//   fRun(),fDebug(),
//   fMsqlHost(msqlhost),fDataPath(fpth),fFileName(fnam),fNevents(nevts),fGebIp(gebip),
//   fStartTime(),fStopTime(),fOnlFlg(),fConsumControlFile(),
//   fTimeLimit(),fTimedOut(),fUpdateEvGap(),fUpdatingProd(),
//   fCurEv(),fRate(),fExitVal(),fManStop(),fPaused(),
//   fHdtRootFile(),
//   fMonSaveThread(),
//   fConfFileRead(),
//   fHdtTree(),fMustSaveHdt(kTRUE)
// {
//   // the PID of current process is stored into a text file

//   fRun = new TFndRun();
  
//   TString cmdpid = TString("echo \"prod: ");
//   cmdpid+=gSystem->GetPid();
//   cmdpid+="\" > ";
//   cmdpid+=FROOT::ExpandPathName(".froot_pid");
//   gSystem->Exec(cmdpid.Data());  


// }

//_____________________________
TFndGeb2hdtMan::TFndGeb2hdtMan(const TString &msqlhost,const TString &fpth,const TString &run_type,const Int_t &run_num,const Int_t &nevts,Int_t gebip):
  fRun(),fDebug(),
  fMsqlHost(msqlhost),fDataPath(fpth),fFileName(),fNevents(nevts),fGebIp(gebip),
  fStartTime(),fStopTime(),fOnlFlg(),fConsumControlFile(),
  fTimeLimit(),fTimedOut(),fUpdateEvGap(),fUpdatingProd(),
  fCurEv(),fRate(),fExitVal(),fManStop(),fPaused(),
  fHdtRootFile(),
  fMonSaveThread(),
  fConfFileRead(),
  fHdtTree(),fMustSaveHdt(kTRUE)
{
  
  // the PID of current process is stored into a text file
  fFileName = BuildRunName(run_type,run_num);
  fRun = new TFndRun();
  
  TString cmdpid = TString("echo \"prod: ");
  cmdpid+=gSystem->GetPid();
  cmdpid+="\" > ";
  cmdpid+=FROOT::ExpandPathName(".froot_pid");
  gSystem->Exec(cmdpid.Data());  
  
}

//_____________________________
TFndGeb2hdtMan::~TFndGeb2hdtMan(){

  //  if(fHdtTree) delete fHdtTree;
  delete fRun;
}

//_____________________________
void TFndGeb2hdtMan::CreateHdtFile(){
  // create new hdt.root file (in $FND_HDT) depending on current run name/number
  
  if(!fMustSaveHdt){
    Info("CreateHdtFile","HDT file will not be created");
    return;
  }
  
  TString start_pth = ExpandPathName("$FND_HDT");
  TString foname;
#if defined _FND_OUTPUTS_USE_SUBDIR
  Bool_t use_subdir = kFALSE;
  if(fOnlFlg == ONL_OFF){
    use_subdir = kTRUE;
    CreateGrpSubDir(fRun->GetRunType(),fRun->GetRunNumber(),start_pth);
  }
  TString BuiltName = BuildRunName(fRun->GetRunType(),fRun->GetRunNumber(),use_subdir);
#else
  TString BuiltName = BuildRunName(fRun->GetRunType(),fRun->GetRunNumber());
#endif
  
  foname.Form("%s/%s.hdt.root",
              start_pth.Data(),
              BuiltName.Data());
  
  Info("TFndRun", "Creating HDT file \"%s\"", foname.Data());
  
  if(fHdtRootFile && fHdtRootFile->IsOpen()) {
    fHdtRootFile->Close(); 
    delete fHdtRootFile;
  }
  fHdtRootFile =  new TFile(foname,"RECREATE","Finuda Hit-Data-Tape file");
  fHdtRootFile->SetCompressionLevel(1);
  
}

//_____________________________
void TFndGeb2hdtMan::WriteHdtFile(){

  if(!fMustSaveHdt) return;

  if(!fHdtRootFile){
    Warning("WriteHdtFile","hdt-file not availabla (check your configuration file)");
    return;
  }
  fHdtRootFile->cd();
  if(fRun->GetGenInfo()) fRun->GetGenInfo()->Write("",TObject::kOverwrite); 
  else Warning("WriteHdtFile", "fGenInfo not available from TFndRun");
  
  if(fRun->GetFeeMap()) fRun->GetFeeMap()->Write("",TObject::kOverwrite) ;
  else Warning("WriteHdtFile", "fFeeMap not available from TFndRun");
  
  Info("WriteHdtFile","==============> Writing HDT TREE...");
  fHdtTree->Write();
  Info("WriteHdtFile","==============> Purging HDT FILE..."); 
  fHdtRootFile->Purge();
  
  fHdtRootFile->Close();
  delete fHdtRootFile; fHdtRootFile = 0;
  
}

//______________________
void TFndGeb2hdtMan::UpdateProducers(){

  HandleConsumerActions(0);      // inhibit consumer(s)

  // GTS histograms update and HDT flush are
  //  faster than others...
  //  ...updating them more often...  

  fUpdatingProd = kTRUE;

  FlushHdtTree();

  if(fRun->GtsMon()) fRun->GtsMon()->Update();

  if(fRun->TofMon()) fRun->TofMon()->Update();

  FlushHdtTree();
  if(fRun->GtsMon()) fRun->GtsMon()->Update(); //

  if(fRun->IsmMon()){
    //    Info("UpdateProducers","Updating ISIM");
    fRun->IsmMon()->Update();
  }
  if(fRun->OsmMon()){
    //    Info("UpdateProducers","Updating OSIM");
    fRun->OsmMon()->Update();
  }

  FlushHdtTree();
  if(fRun->GtsMon()) fRun->GtsMon()->Update(); //

  if(fRun->LmdMon()) fRun->LmdMon()->Update();

  FlushHdtTree();
  if(fRun->GtsMon()) fRun->GtsMon()->Update(); //

  if(fRun->StbMon()) fRun->StbMon()->Update();  

  TouchMapFiles();


  //  Info("UpdateProducers","===> All monitors updated(producer) <===");
  
  HandleConsumerActions(1);      // inhibit consumer(s)

  fUpdatingProd = kFALSE;

  return;
}

//_____________________________
void TFndGeb2hdtMan::FlushHdtTree(){
  // used in online-mode only in order to update
  // the content of shared HDT tree (used by the Event-Display)

  //   Info("FlushHdtTree","method disabled");
  //   return;

  if(!fMustSaveHdt) return;

  if(!fHdtRootFile){
    Warning("FlushHdtTree","hdt-file not availabla (check your configuration file)");
    return;
  }

  //  Info("FlushHdtTree","cd-ing");
  fHdtRootFile->cd();
  fHdtTree->AutoSave("SaveSelf");
  
  //   Info("FlushHdtTree","writing");
  //   fHdtTree->Write();
  //   Info("FlushHdtTree","purging");
  //   fHdtRootFile->Purge();
  //   Info("FlushHdtTree","flushing");
  //   fHdtRootFile->Flush();
  Info("FlushHdtTree","done");
  usleep(5000000);

}

//_____________________________
void TFndGeb2hdtMan::ReadConfFile(){

  if(!fRun) TerminateFroot(0,"TFndGeb2hdtMan::ReadConfFile ---> fRun not defined!");

  // Configuration file
  cout << "Reading configuration file." << endl;
  fRun->ReadConfigFile();
  fRun->RunConfiguration()->Print();

  fDebug = fRun->RunConfiguration()->Debug(); 
  fUsingGUI = fRun->RunConfiguration()->Geb2hdtUsingGUI();

  fUpdateEvGap = fRun->RunConfiguration()->Geb2hdtUpdateEvGap();
  fMustSaveHdt = fRun->RunConfiguration()->GetMustSaveHdt();
  // ---
  fConfFileRead = kTRUE;
}

//_____________________________
void TFndGeb2hdtMan::InitRun(){

  if(!gSystem->AccessPathName(".froot_onlstopped") ) gSystem->Exec("rm -f .froot_onlstopped");

  TDatime start_time = TDatime();
  fStartTime = (Int_t)start_time.Convert();
  fStopTime = fStartTime; // this will change

  // build up input file name
  cout << endl << " -> mSQL DB Host: " << fMsqlHost.Data() << endl;
  cout << " -> Data path: "    << fDataPath.Data() << endl;
  cout << " -> Run: "          << fFileName.Data() << endl;
  cout << " -> " << fNevents << " events will be processed." << endl;
  
  TString grptit = TString("");

  if(!fConfFileRead) ReadConfFile();

  fRun->SetDataPath(fDataPath);
  fRun->SetDBHost(fMsqlHost);
  //
  fRun->SetMaxNumberOfEvents(fNevents);
  
  cout << "TFndGeb2hdtMan::InitRun ---> debug_lev = " << fDebug << endl;
  printf("TFndGeb2hdtMan::InitRun ---> debug_raw = 0x%x\n",fRun->GetDebugRawEv());

  // temporary: MUST MODIFY geb2hdt!
  TString run_type = fFileName;
  run_type.Resize(4);
  TString num = fFileName;
  num.Remove(0,4);
  Int_t run_num = num.Atoi();

  if(!run_type.CompareTo("ONLM")) run_num = -1;
  Int_t in_val = fRun->InitNewRun(run_type,run_num);
  if (in_val == -3) TerminateFroot(0,TString("wrong argument received as \"run-type\" (\""+run_type)+"\").");  
  if(in_val != 0){
    fExitVal = 4;
    FinishRun();
    return;
  }
  //............. set host, path, run, gebip number of events
  // perform old constructor operations
  fOnlFlg = fRun->Onlflg();
  cout << "fndrun constructed: online flag is: " << fOnlFlg << endl;
  
  fConsumControlFile = ExpandPathName("$FND_SHR/.shared_msg.txt");
  // connection to database is automatically handled directly by TFndRun
  
  CreateHdtFile();
  
  // If you are wondering why "Bronch"
  // is used instead of "Branch" don't change it.
  fHdtTree= new TTree("FIN_HDT_TREE","Tree with FINUDA hdt-events");
  fHdtTree->Bronch("fndhdt","TFndHdt",&TFndRun::fgFinHdt,128000,1);
  if(fOnlFlg == ONL_ALL ) fHdtTree->SetCircular(5000);
  //  if(geb_run->GetOnlFlag() == ONL_ALL ) fHdtTree->SetCircular(5000);
}

//___________________
void TFndGeb2hdtMan::EventLoop(){
  // fExitVal values:
  //               -2: No answer received from DAQ (online mode only
  //               -1: DB error
  //                0: next event will be processed
  //                1: requested number of events reached
  //                2: end of run reached
  //                3: process timed out
  //                4: requested run was not found
  //
  // fManStop is not dependent on fExitVal

  Int_t RateCheck1 = 0;
  Int_t RateCheck2 = 0;

  RealTimeInfo(G2H_INFO_EV_LOOP_START,"EventLoop","Starting event loop...");
  StartMonitors();

  if(fOnlFlg) RealTimeInfo(G2H_INFO_CAN_START_CONS,"EventLoop","Shared memories created: Consumer can start");
  while(!fExitVal && !fManStop) {
    if(fPaused){
      gSystem->Sleep(500);
      continue;
    }
    
    if(fTimedOut){
      fExitVal = 3;
      return;
    }

    // exit if timed-out
    TDatime stop_time = TDatime();
    fStopTime = (Int_t)stop_time.Convert();
    if(fTimeLimit>=0 && (fStopTime - fStartTime) > fTimeLimit) {
      fTimedOut = kTRUE;
      RealTimeInfo(G2H_INFO_TIMED_OUT,"EventLoop","Process has timed out");
      cout << "process time-out" << endl;
    }
    //
    // --- event processing    
    if(fOnlFlg){
      if(fCurEv == 0) RealTimeInfo(G2H_INFO_SEND_FIRST_REQ,"EventLoop","Sending request for the first event...");
      else if(fCurEv == 1){
        RealTimeInfo(G2H_INFO_PRINT,"EventLoop","Monitoring process started");
        StartSavingThread();
      }
    }    
    
    fExitVal = fRun->GetNextEvent(kTRUE);
    //     fRun->GetNextRawEvent(fExitVal); // already performend by GetNextEvent(kTRUE)
    //     if(fExitVal == 0) fExitVal = fRun->ReadRawEvent(); // already performed by GetNextEvent(kTRUE)

    if(fExitVal == 0 && fHdtTree){
      Int_t fill_size = fHdtTree->Fill();
      if(fDebug) Info("EventLoop","Filled  (ev %d : size: %d)\n",fRun->GetEvNum_Raw(),fill_size);
    }


    if(fOnlFlg && fRun->GetNofProcessedEvents()%10 == 0 && fRun->GetCurOnlineRunNmber() > 0){
      cerr << "Producer msg ===> Run: " << fRun->GetCurOnlineRunNmber() << "; Last event: " << fRun->GetEvNum_Raw() << endl;;
    }
    
    // --- stop management: see "TFndRun::GetNextEvent"
    if(fExitVal == 1) { // requested number of events reached
      cout << "fExitVal: " << fExitVal << endl;
      //      fCurEv--;
      fRun->ClearEvent(); //fRun->CleanEvent() called by TFndRun::FinishRun();
      break;
    }    
    else if(fExitVal == 2) { // end of run reached
      fRun->ClearEvent(); //fRun->CleanEvent() called by TFndRun::FinishRun();
      return; 
    }
    else if(fExitVal == -1){ // DB-error
      fRun->ClearEvent(); //fRun->CleanEvent() called by TFndRun::FinishRun();
      cout << "Database error" << endl;
      break;
    }
    else if(fExitVal == -2){ // No answer received from DAQ (online mode only)
      RealTimeInfo(G2H_INFO_NO_ANSWER,"EventLoop","No answer received from DAQ...retrying...");
      gSystem->Sleep(500);
      RealTimeInfo(G2H_INFO_SEND_REQ_TO_DAQ,"EventLoop","Sending new event request to DAQ...");
      //      fCurEv--;
      fExitVal = 0;
      fRun->ClearEvent();
      continue;
    }
    if(fExitVal != 0){ // check (could be removed in the future...)
      Error("EventLoop","Maybe you have found a BUG!");
      TerminateFroot(0,"Application BUG!");
    }
    // --- if you are here, then you have correctly processed this event
    fCurEv++;
    //    Info("EventLoop","==============================> %d",fCurEv);
    
    if(PrintInfo(RateCheck1,RateCheck2)){
      
      TString grp_msg = TString("");
      //       if(fOnlFlg){
      //        RealTimeInfo(G2H_INFO_UPDATING_PROD_SHR,"EventLoop","Updating producer shared memories");
      //        //      UpdateProducers(); // handled within the dedicated thread
      //        //      TThread::Lock();
      //        //      WriteHdtFile();
      //        //      TThread::UnLock();
      //        grp_msg.Form("Last update at event %d",fCurEv);
      //       }
      //       else grp_msg.Form("%s%d: event %d",fRun->GetRunType().Data(),fRun->GetRunNumber(),fCurEv);
      // ---
      
      if(fTimeLimit>=0){
        grp_msg+=" ; time remaining: ";
        grp_msg+=fTimeLimit - (fStopTime-fStartTime);
        grp_msg+=" s.";
      }
      else grp_msg+=" ; time unlimited.";
      //
      fLastUpdEv = fCurEv;
    }
    fRun->ClearEvent();
    //fRun->CleanEvent() called by TFndRun::FinishRun();
  }
  StopSavingThread();
  //  cout << "store on output file at event " << fCurEv << endl;
  printf("Elapsed time: %d s\n",(Int_t)(fStopTime-fStartTime));
  return;
}

//________________________________
void TFndGeb2hdtMan::StartMonitors(){
  
  TString msg = "";
  msg.Form("Starting monitors (online flag = %d)",fOnlFlg);
  RealTimeInfo(G2H_INFO_STARTING_MONITORS,"Starting Monitors",msg);
  
  //  HandleConsumerActions(0); // inhibit consumer(s)
  // if(fOnlFlg) TMapFile::SetMapAddress(K_MapsStartAddress); 
  fRun->StartMonitors();
  //#if defined _FND_ONL_USE_MAP_FILES_
  //  if(fOnlFlg) UpdateProducers();
  //#endif
  //if(fOnlFlg) TouchMapFiles();
  //  HandleConsumerActions(1); // allow consumer(s)
  return;
}

//__________________________________________________________
void TFndGeb2hdtMan::FinishRun(){
  // fExitVal values:
  //               -2: No answer received from DAQ (online mode only)
  //               -1: DB error
  //                0: next event will be processed
  //                1: requested number of events reached
  //                2: end of run reached
  //                3: process timed out
  //                4: file not foud during initialization
  
  //  HandleConsumerActions(1);  // allow consumer(s)
  while(fUpdatingProd){
    Info("FinishRun","Waiting for producer update to be completed");
    gSystem->Sleep(1000);
  }

  cout << "________________________________________________" << endl;
  TString msg = TString();
  switch(fExitVal){
  case -2: msg = "No answer received from DAQ";                     break;
  case -1: msg = "DB error";                                        break;
  case  1: msg.Form("Requested number of events reached (%d)");     break;
  case  2: msg = "End of run reached: ";                            break;
  case  3: msg.Form("geb2hdt process timed out (%d s)",fTimeLimit); break;
  case  4: msg.Form("Requested run not found."); break;
  default:
    if(fManStop) msg = "geb2hdt process manually stopped.";
    else{
      msg.Form("What's happening? fExitVal = %d --- fManStop = %d",fExitVal,fManStop);
      Warning("FinishRun","Unexpected value for fExitVal");
    }
    break; 
  }
  RealTimeInfo(G2H_INFO_FINISH_RUN,"FinishRun",msg);
  //  fTextMessages->SetText(msg.Data());
  printf("TFndGeb2hdtMan::FinishRun ---> \"%s\"\n",(Char_t *)msg.Data());
  printf("Total number of events =====> %d\n",fCurEv);
  printf("Elapsed time: %d s\n",(Int_t)(fStopTime-fStartTime));
  cout << "________________________________________________" << endl;

  fRun->FinishRun(kTRUE);
  WriteHdtFile();

  cout << "HDT file written" << endl;
  TDatime end_time = TDatime();
  fStopTime = end_time.Convert();

  TString final_msg = "";
  final_msg.Form("geb2hdt process completed...elapsed time: %d s",(Int_t)(fStopTime-fStartTime));
  cout << final_msg.Data() << endl;
  RealTimeInfo(G2H_INFO_EXITING,"FinishRun",final_msg);
  
  Info("FinishRun","files closed...");
  cout << "geb2hdt completed" << endl;
  
}

//_____________________________
void TFndGeb2hdtMan::StopProducer() { 
  // Method used to stop the current producer from outside
  // (GUI button or user macro)

  RealTimeInfo(G2H_INFO_STOPPING,"StopProducer","...stopping producer...");
  fManStop = kTRUE;
  gSystem->Exec("touch .froot_onlstopped");
}

//_____________________________
void TFndGeb2hdtMan::PauseProducer() { 
  //  HandleConsumerActions(1);  // allow consumer(s)
  fPaused = !fPaused;
  
  if(fPaused) RealTimeInfo(G2H_INFO_PAUSED,   "PauseProducer","Producer paused");
  else        RealTimeInfo(G2H_INFO_RESTARTED,"PauseProducer","Producer restarted");
}
//__________________________________________________________
Int_t TFndGeb2hdtMan::TouchMapFiles(){
  // simply touch all shared map-files
  // needed by NFS to update consumer(s)
  //  
  // return value:
  //           number of touched map-files

#if !defined _FND_ONL_USE_MAP_FILES_
  return 0;
#endif
  
#if !defined _FND_USE_TOUCH_MAP_FILES
  return 0;
#endif
  
  Info("TouchMapFiles"," Touching all shared files...");
  //   gSystem->Sleep(300);
  //   gSystem->ProcessEvents();
  const Int_t nmaps = 18;

  TString MapsList[nmaps];
  MapsList[0]  = "lmd.map";
  MapsList[1]  = "lmd_o_adc.map";
  MapsList[2]  = "stb.map";
  MapsList[3]  = "stb_tdc_3.map";
  MapsList[4]  = "stb_tdc_6.map";
  MapsList[5]  = "tof_tdc.map";
  MapsList[6]  = "gts.map";
  MapsList[7]  = "lmd_i_adc.map";
  MapsList[8]  = "lmd_o_tdc.map";
  MapsList[9]  = "stb_tdc_1.map";
  MapsList[10] = "stb_tdc_4.map";
  MapsList[11] = "tof_adc.map";
  MapsList[12] = "ism.map";
  MapsList[13] = "lmd_i_tdc.map";
  MapsList[14] = "osm.map";
  MapsList[15] = "stb_tdc_2.map";
  MapsList[16] = "stb_tdc_5.map";
  MapsList[17] = "tof_map.map";
  
  Int_t touch_counter = 0;
  TString PathString;
  for(Int_t i=0;i<nmaps;i++){
    PathString.Form("$FND_SHR/%s",MapsList[i].Data());
    if(!gSystem->AccessPathName(FROOT::ExpandPathName(PathString.Data()).Data())){ // 0 if found
      TString touch_str = TString("touch ");
      touch_str += FROOT::ExpandPathName(PathString.Data()).Data();
      gSystem->Exec(touch_str.Data());
      gSystem->ProcessEvents(); 
      if(fDebug) Info("TouchMapFiles()","Map file \"%s\" touched",FROOT::ExpandPathName(PathString.Data()).Data());
      touch_counter++;
    }
  }
  if(!touch_counter) Warning("TouchMapFiles()","Shared mmories not found!");
  return touch_counter;
}


//__________________________________________________________
void TFndGeb2hdtMan::HandleConsumerActions(Bool_t allow){
  // the content of the shared text file '.shared_msg.txt' is
  // used by the consumer(s).
  // Consumer(s) can act (open, read...map-files) if 'allow' is true

  // shared messages are needed only while using TMapFile

#if !defined _FND_USE_HANDLE_CONSUMER_ACTIONS
  return;
#endif

#if !defined _FND_ONL_USE_MAP_FILES_
  return;
#endif

  if(!fOnlFlg) return; // not needed while working offline

  Info("TFndGeb2hdtMan::HandleConsumerActions","allow: %d",allow);
  
  TString com = TString("echo ");
  Int_t size1 = com.Sizeof()-1;
  
  if(allow) com+="\"go\" > ";
  else com+="\"wait\" > ";

  com+=fConsumControlFile.Data();
  gSystem->Exec(com.Data());

  com.Resize(size1);
  com+="\"\" >> ";
  com+=fConsumControlFile.Data();
  gSystem->Exec(com.Data());
}

//__________________________________________________________
void TFndGeb2hdtMan::KillYourself(){

  TString pid_kill = TString("kill -9 ");
  
  FILE *f = fopen(FROOT::ExpandPathName(".froot_pid"),"r");
  Char_t file[200][200];
  if(!f){
    gROOT->Warning("TFndGeb2hdtMan::KillYourself","PID file not found"); // must use gROOT (static method)
    return;
  }
  TString cur_line = TString();
  int l=0;
  const Char_t *prod_pid = 0;
  while (fgets(file[l],200,f)) { 
    Char_t *line=file[l++];
    if(strlen(line)<2) continue;
    line[strlen(line)-1]='\0';
    cur_line = line;
    printf("line: \"%s\" --- cur_line: \"%s\"\n",line,(Char_t *)cur_line.Data());
    Int_t SpacePos = (Int_t) cur_line.Index(" ");
    printf("space at pos: %d\n",SpacePos);
    if(!strncmp(cur_line.Data(),"prod:",SpacePos)){ 
      prod_pid = ((TSubString)(cur_line.SubString("",SpacePos+1))).Data(); // read content after space
      }
  }
  pid_kill += prod_pid;
  gROOT->Info("TFndGeb2hdtMan::KillYourself","Killing producer "); // must use gROOT (static method)
  gROOT->Warning("TFndGeb2hdtMan::KillYourself","Shared memories will not be cleaned yet!"); // must use gROOT (static method)
  gSystem->Exec(pid_kill.Data());
}

//__________________________________________________________
Int_t TFndGeb2hdtMan::PrintInfo(Int_t &rate1,Int_t &rate2){
  // emit a signal here! (RealTimeInfo)    
  // return value:
  //              1: printing information (producer needs to be updated)
  //              0: not printing information (producer does not need to be updated)
  //
  // This will drive the ONLINE-HDT producer update

  Int_t LastProcEvts = fCurEv - fLastUpdEv;

  Int_t minimumnum; // don't allow producer histos before this
  Int_t minimumsec; // don't allow producer histos before this
  Int_t maximumsec; // update producer histos in any case
#if defined _FND_ONL_USE_SHARED_FILES_
  minimumnum = 10; // was 100 before using the separate thread for saving histos
  minimumsec = 5; // was 60 before using the separate thread for saving histos
  maximumsec = 15; // was 120 before using the separate thread for saving histos
  //  return 0;
#elif defined _FND_ONL_USE_MAP_FILES_
  minimumnum = 30;
  minimumsec = 5;
  maximumsec = 10;
#endif

  //  cout << " -> Processing event: " <<  fCurEv << "; fLastUpdEv: " << fLastUpdEv << "; LastProcEvts: " << LastProcEvts << endl;;

  if(LastProcEvts < minimumnum) return 0;
    
  //  Printf(" -> Processing event: %d",fCurEv);
  TDatime check_time = TDatime();
  rate2 = (Int_t)check_time.Convert();
  if(!rate1) rate1 = fStartTime;

  if((Int_t)(rate2-rate1) < minimumsec && fOnlFlg == ONL_ALL ) return 0;
  if((Int_t)(rate2-rate1) < maximumsec && LastProcEvts < fUpdateEvGap) return 0;
  // the following code will be executed after having processed 'fUpdateEvGap' events
  //  or every three seconds (if the monitor is receiving events)

  
  fRate = (Int_t )((Float_t)(LastProcEvts) / (Float_t)(rate2-rate1));
  TString info_msg;
  
  Int_t crun =  fndrun->GetRunNumber();
  if (crun == -1) crun = (Int_t) fndrun->GetCurOnlineRunNmber();
  
  if(rate2-rate1 > 0)
    info_msg.Form(" -> Run %d - Event %d (%d ev. processed in %d s: running at %d ev/s)",
                  crun,
                  fCurEv,LastProcEvts,
                  (Int_t)(rate2-rate1),
                  fRate);
  else 
    info_msg.Form(" -> Run %d - Event %d (%d ev. processed in %d s)",
                  crun,
                  fCurEv,
                  LastProcEvts,
                  (Int_t)(rate2-rate1));

  Info("PrintInfo",info_msg.Data());
  RealTimeInfo(G2H_INFO_PRINT,"PrintInfo","Printing information about the running producer...");
  
  rate1 = rate2;
  return 1;
}

//________________________________
void TFndGeb2hdtMan::ResetGts(){
  
  //  if(!fRun->Rdt()->Gts()) return; 
  RealTimeInfo(G2H_INFO_RESET_GTS,"ResetGts","Resetting GTSshared memories");
  fRun->GtsMon()->ResetHistos();
  fRun->GtsMon()->Update();
}

//________________________________
void TFndGeb2hdtMan::ResetTof(){ 
  
  //  if(!fRun->Rdt()->Tof()) return;
  RealTimeInfo(G2H_INFO_RESET_TOF,"ResetTof","Resetting TOF shared memories");
  fRun->TofMon()->ResetHistos();
  fRun->TofMon()->Update();
  
}

//________________________________
void TFndGeb2hdtMan::ResetSil(){

  //  if(!fRun->Rdt()->Ism() || !fRun->Rdt()->Osm()) return;
  RealTimeInfo(G2H_INFO_RESET_SIL,"ResetSil","Resetting SILshared memories");
  fRun->IsmMon()->ResetHistos();
  fRun->OsmMon()->ResetHistos();
  fRun->IsmMon()->Update();
  fRun->OsmMon()->Update();
}

//________________________________
void TFndGeb2hdtMan::ResetLmd(){

  //  if(!fRun->Rdt()->Lmd()) return;
  RealTimeInfo(G2H_INFO_RESET_LMD,"ResetLmd","Resetting LMDshared memories");
  fRun->LmdMon()->ResetHistos();
  fRun->LmdMon()->Update();
}

//________________________________
void TFndGeb2hdtMan::ResetStb(){

  //  if(!fRun->Rdt()->Stb()) return;
  RealTimeInfo(G2H_INFO_RESET_STB,"ResetStb","Resetting STBshared memories");
  fRun->StbMon()->ResetHistos();
  fRun->StbMon()->Update();
}


//__________________________________________________________
void TFndGeb2hdtMan::RealTimeInfo(Int_t Info_id,TString method,TString info){
  // required by the related GUI (if used)
  Info(method,info);
  SendRealTimeInfo(Info_id);
}

//__________________________________________________________
void TFndGeb2hdtMan::SendRealTimeInfo(Int_t Info_id){
  // required by the related GUI (if used)
  // remember to check for "TFndGeb2hdtMan::fExitVal" and "TFndGeb2hdtMan::fManStop" in case of "Info_id==G2H_INFO_FINISH_RUN"

  Emit("SendRealTimeInfo(Int_t)",Info_id);
}

//__________________________________________________________
void *TFndGeb2hdtMan::SavingThread(void *arg){
  // Update producer outputs within a dedicate thread
  // In this way the update process is continuous
  // (even while filling histograms)

  TFndGeb2hdtMan *context = (TFndGeb2hdtMan *)arg;

  while(1){
    printf("------------ Monitor Saving thread (%d)\n",context->GetCurrentEvent());
    TThread::CancelPoint();
    context->UpdateProducers();
    usleep(10000000);
    //context->WriteHdtFile();
    //    cout << "------------ ----- Cancel point passed" << endl;
  }
}

//__________________________________________________________
void TFndGeb2hdtMan::StartSavingThread(){
  
  cout << "Starting \"Monitor Saving thread\"" << endl;
  fMonSaveThread = new TThread("Monitor_Saver",SavingThread,(void *)this);

  TThread::SetCancelOff(); // this is the default
  TThread::SetCancelDeferred(); // this is the default

  fMonSaveThread->Run();
  
}

//__________________________________________________________
void TFndGeb2hdtMan::StopSavingThread(){
  
  if(fMonSaveThread){
    if(fMonSaveThread->GetState() == TThread::kRunningState){
      cout << "killing \"Monitor Saving thread\"" << endl;
      fMonSaveThread->Kill();
      TThread::Delete(fMonSaveThread);
      delete fMonSaveThread;
      fMonSaveThread = 0;
    }
    else cout << "Monitor Saving thread found, but not running" << endl; 
  }
  else cout << "Monitor Saving thread not found" << endl;


  
}

---