mcr/prean/FinudaPreanalysis.C

//   Author: Diego Faso                                                                 //

#include <Riostream.h>
#include "TROOT.h"
#include "TSystem.h"
#include "TApplication.h"

#include "TString.h"

#include "TFndHdt.h"
#include "TFndPreanMan.h"
#include "TFndPrean.h"

class TFndPreanProcess: public TObject{

public:
  enum E_FollowControl{
    E_Follow_NotUsed = -1, // init only
    E_Follow_GoToNext = 0,
    E_Follow_RetryThis = 1,
    E_Follow_ProcessThis = 2,
  };

  
private:
  TFndPreanMan *fPreanMan;

  TString fDBhost;
  TString fDataPath;
  TString fRunType;

  Int_t fFirstRun;
  Int_t fLastRun;
  Bool_t fIsLastRun;

  Int_t fDebugLevel;

  Int_t fTotEvCount;
  Int_t fTotEvTgt;
  Int_t fEvPerRunTgt;
  Int_t fCurEv;
  Int_t fIncrement;
  Int_t fCurrentRun;
  TString fLogFileName;
  TString fLogMsg;

  // ---
  TDatime fCheckTime_Now;
  Int_t fStartTime;
  Int_t fStopTime;
  
private:
  Int_t RunLoop();
  Int_t FollowDAQ(); // alternative to RunLoop()

public:
  
  TFndPreanProcess();
  ~TFndPreanProcess();

  void SetDebugLevel(const Int_t &debug_lev) { fDebugLevel = debug_lev; }

  void SetDBhost(const TString &db_host) { fDBhost = db_host; }
  void SetDataPath(const TString &data_path) { fDataPath = data_path; }
  void SetRunType(const TString &run_type) { fRunType = run_type; }

  void SetCurrentRun(const Int_t &run_num) { fCurrentRun = run_num; }

  void SetRunEventTarget(const Int_t &nevt) { fEvPerRunTgt = nevt; }
  void SetTotEventTarget(const Int_t &nevt) { fTotEvTgt = nevt; }

  void SetFirstRun(const Int_t &num) { fFirstRun = num; }
  void SetLastRun(const Int_t &num) { fLastRun = num; }

  Int_t ProcessPreanalysis(); // mode handled depending on first/last run

  void StartTimeCheck();
  void StopTimeCheck();
  void EventLoop();
  Int_t ProcessSingleRun();

  Int_t CheckRuns();

  ClassDef(TFndPreanProcess,0)
};

ClassImp(TFndPreanProcess)

//___________________________________
TFndPreanProcess::TFndPreanProcess():
  fPreanMan(),fDBhost(),fDataPath(),fRunType(),
  fFirstRun(),fLastRun(),fIsLastRun(),
  fDebugLevel(),
  fTotEvCount(),fTotEvTgt(),fEvPerRunTgt(),fCurEv(),fIncrement(),fCurrentRun(),fLogFileName(),fLogMsg(),
  fCheckTime_Now(),fStartTime(),fStopTime()
{
  
  fStartTime = 0;
  fStopTime = 0;
  fTotEvCount = 1;

}

//___________________________________
TFndPreanProcess::~TFndPreanProcess(){

  cout << endl << endl << "    -> Destroying the preanalysis manager..." << endl;
  delete fPreanMan;
}


//___________________________________
void TFndPreanProcess::StartTimeCheck(){

  fCheckTime_Now.Set();
  fStartTime = fCheckTime_Now.Convert();
}

//___________________________________
void TFndPreanProcess::StopTimeCheck(){

  fCheckTime_Now.Set();
  fStopTime = fCheckTime_Now.Convert();
  Int_t rate = Int_t ( (Float_t)fCurEv / (Float_t)(fStopTime - fStartTime) );

  cout << endl << " --- --- --- --- --- --- --- --- --- --- --- ---" << endl;
  if(fCurEv >0) fLogMsg.Form("Performances test: %d events processed in %d s ===> %d ev/s",fCurEv, fStopTime - fStartTime, rate );
  else fLogMsg.Form("Performances test: elapsed time: %d s",fStopTime - fStartTime );
  cout << fLogMsg << endl;  
  cout << " --- --- --- --- --- --- --- --- --- --- --- ---" << endl << endl;
  fPreanMan->WriteLogFile(fLogMsg);
  fPreanMan->WriteLogFile("\n --- --- --- --- --- --- --- \n\n");
}

//___________________________________
void TFndPreanProcess::EventLoop(){
  
  while(1){
    if( fCurEv % 300 == 0 ) gROOT->Info("FinudaPreanalysis","Processing run %s-%d ===> event %d",fRunType.Data(),fCurrentRun,fCurEv);
    if(fTotEvTgt != -1 && fTotEvCount > fTotEvTgt){
      Printf("PreanalyzeRun ---> maximum number of events reached for current preanalysis process");
      return;
    }
    if(fEvPerRunTgt != -1 && fCurEv > fEvPerRunTgt){
      Printf("PreanalyzeRun ---> maximum number of events reached for current run");
      return;
    }
    if( fPreanMan->GetNextFidaEvent() != 0) return; // exit loop if run completed
    fPreanMan->AnalyzeJFGES();
    if( fPreanMan->ReconstructFidaEvent() !=0) return; // exit loop in case of problems
    fPreanMan->AnalyzeJFDST();
    fCurEv++;
    fTotEvCount++;
  } // event loop completed
  
}

//___________________________________
Int_t TFndPreanProcess::ProcessPreanalysis(){
  // return value:
  //              0: ok
  //             -1: process mode undefined
  
  if(fPreanMan){
    Error("ProcessPreanalysis","fPreanMan should not be defined yet!");
    delete fPreanMan;
    TerminateFroot();
  }
  fPreanMan = new TFndPreanMan(fDBhost,fDataPath,fDebugLevel);

  if (fFirstRun == 0 && fLastRun == 0){
    Warning("ProcessPreanalysis()","Can not determine process mode");
    return -1;
  }
  
  Int_t ret_val = 
    (fLastRun == -1) ? 
    FollowDAQ() :
    RunLoop();

  return ret_val;
}


//___________________________________
Int_t TFndPreanProcess::ProcessSingleRun(){
  // return value:
  //              0: ok
  //             -1: run initialization not possible 

  Int_t initval = fPreanMan->InitNewPreanRun(fRunType,fCurrentRun); // offline mode
  if(initval!=0){
    //      Printf("initval: %d",initval);
    fPreanMan->FinishPreanRun(kFALSE);
    fCurrentRun += fIncrement;
    Printf("\n --- --- --- --- \n"); // simply nice ;)
    return -1;
  }
  
  fLogFileName.Form("%s_prean.log",BuildRunName(fRunType,fCurrentRun).Data());
  fPreanMan->OpenLogFile("$PWD",fLogFileName);
  Printf("New run started (%s %d)",fRunType.Data(),fCurrentRun);
  
  fCurEv = 1; // reset single run event counter
  StartTimeCheck(); //
  
  fLogMsg.Form("Process Start time: %s",fCheckTime_Now.AsString() );
  fPreanMan->WriteLogFile(fLogMsg);
  fLogMsg.Form(" FIDARC release: \"%s\"\n",FIN_PHYS::FidaVer_Name().Data() );
  fPreanMan->WriteLogFile(fLogMsg);
  
  // ---
  EventLoop();
  // ---
  
  fPreanMan->FinishPreanRun(fIsLastRun); // last run completed

  // ---
  fLogMsg.Form("\nProcess end time: %s",fCheckTime_Now.AsString());
  fPreanMan->WriteLogFile(fLogMsg);
  StopTimeCheck(); // will add statistics to current log file
  fPreanMan->CloseLogFile();
  // ---
  
  Printf("\n --- --- --- --- \n"); // simply nice ;)
  
  return 0;
}


//___________________________________
Int_t TFndPreanProcess::RunLoop(){
  
  if(!fPreanMan){
    Error("RunLoop","fPreanMan not defined");
    TerminateFroot();
  }

  Info("RunLoop","Starting loop on runs (%d -> %d)",fFirstRun,fLastRun);

  fCurrentRun = fFirstRun;
  fIncrement = (fLastRun >= fFirstRun) ? +1 : -1;
  
  while(1){ // run loop
    if(fLastRun >= fFirstRun && fCurrentRun > fLastRun) break;    
    else if(fLastRun < fFirstRun && fCurrentRun < fLastRun) break; // allow reverse processing
    
    if(fTotEvTgt != -1 && fTotEvCount >= fTotEvTgt){
      Printf("RunLoop ---> maximum number of events reached for current preanalysis process");
      break;
    }
    
    fIsLastRun = (fCurrentRun == fLastRun)? kTRUE : kFALSE;
    if(ProcessSingleRun() == -1) continue;
    
    if(fCurrentRun == -1) break; // one initialization only in online-mode
    
    //
    fCurrentRun += fIncrement;
  } // run loop completed
  
  fPreanMan->CloseInterface(); // close used reconstruction (dynamic) library
  
  return 0;
  
}

//___________________________________
Int_t TFndPreanProcess::CheckRuns(){
  // return value:
  //       E_Follow_GoToNext
  //       E_Follow_RetryThis
  //       E_Follow_ProcessThis

  // ---  
  TString chk_start;
  TString chk_raw;
  TString chk_raw_gz;
  TString chk_form;
  // ---

  Bool_t exists[4];
  Bool_t form_exists[4];

  for(Int_t i=0;i<4;i++){
    exists[i] = kFALSE;
    form_exists[i] = kFALSE;
    
    chk_start.Form("%s/%s",
                   ExpandPathName(fDataPath).Data(),BuildRunName(fRunType,fCurrentRun+i).Data());
    
    chk_raw.Form("%s.raw",chk_start.Data());
    chk_raw_gz.Form("%s.raw.gz",chk_start.Data());
    chk_form.Form("%s.raw_form.txt",chk_start.Data());
    // ---  
    
    // if !cur && ( cur+1 || cur+2 || cur+3 ) ===> next
    // if (!cur+1 && !cur+2 && !cur+3) ===> retry
    if( !gSystem->AccessPathName(chk_raw) || !gSystem->AccessPathName(chk_raw_gz) ) exists[i] = kTRUE;
    if( !gSystem->AccessPathName(chk_form) ) form_exists[i] = kTRUE;

    //    cout << "chk_start: \"" << chk_start << "\" ---> " << exists[i] << " ===> " << form_exists[i] << endl;

  }
  
  Int_t ret_val = -1;

  if(!exists[0] && ( exists[1] ||  exists[2] ||  exists[3] ) ) ret_val = (Int_t) E_Follow_GoToNext;
  else if( !exists[1] && !exists[2] && !exists[3] ) ret_val = (Int_t) E_Follow_RetryThis;
  else{
    ret_val = (Int_t) E_Follow_ProcessThis;
    
    if(!form_exists[0]){
      Warning("CheckRuns","Form-file does not exist");
    }
  }

  return ret_val;
}

//___________________________________
Int_t TFndPreanProcess::FollowDAQ(){
  // alternative to RunLoop()
  //  used to follow DAQ closed runs

  if(!fPreanMan){
    Error("FollowDAQ","fPreanMan not defined");
    TerminateFroot();
  }

  Info("FollowDAQ","Starting in \"DAQ-follow\" mode");

  
  fCurrentRun = fFirstRun;

  E_FollowControl pr_fl = E_Follow_NotUsed; // process flag
  while(1){
    // ---
    if(fTotEvTgt != -1 && fTotEvCount >= fTotEvTgt){
      Printf("FollowDAQ ---> maximum number of events reached for current preanalysis process");
      break;
    }
    
    pr_fl = (E_FollowControl) CheckRuns();
    
    switch(pr_fl){
    case E_Follow_GoToNext:
      fCurrentRun++;
      Info("FollowDAQ","switching to run number %d",fCurrentRun);
      break;// will continue loop incrementing run-number
    case E_Follow_RetryThis:
      Info("FollowDAQ","waiting for run number %d to be completed",fCurrentRun);
      gSystem->Sleep(3000);
      break; // will continue loop without incrementing run-number
    case E_Follow_ProcessThis:
      Info("FollowDAQ","ready to process run number %d",fCurrentRun);
      ProcessSingleRun();
      fCurrentRun++;
      break;
    default:
      Error("FollowDAQ","Don't know what to do!");
      TerminateFroot();
    }
    
  }

  
  return 0;
}

//_______________________________
// void FinudaPreanalysis(TString run_type="FINU",Int_t first_run = -1,Int_t last_run = -1,Int_t n_evs_run=-1,Int_t n_evs_tot=-1){
//   // NOTE:
//   //      in order to follow DAQ close run use "last_run = -1"

//   Int_t debug_lev = 0;

//   TFndPreanProcess *PreanProc = new TFndPreanProcess();

//   PreanProc->SetDBhost("$MSQL_DB_HOST");
//   PreanProc->SetDataPath("$RDT");
//   PreanProc->SetRunType(run_type);
//   PreanProc->SetRunEventTarget(n_evs_run);
//   PreanProc->SetTotEventTarget(n_evs_tot);
//   PreanProc->SetDebugLevel(debug_lev);

//   PreanProc->SetFirstRun(first_run);
//   PreanProc->SetLastRun(last_run);


//   cout << " -> FinudaPreanalysis starting ..." << endl;
  
//   PreanProc->ProcessPreanalysis();

  
  
//   // ---
//   delete PreanProc; // free used memory
  
//   cout << "    -> done!" << endl;
//   cout << " -> FinudaPreanalysis completed!" << endl;
// }

---