PREAN/TFndPreanProcess.cxx

// @(#)fROOT/PREAN:$Name:  $:$Id: TFndPreanProcess.cxx,v 1.4 2007/09/24 07:32:41 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2007/01/15

//  This class is designed in order to drive the preanalysis process.          //
//  TFndPreanMan is used and the support for multi-run processing is provided. //
//                                                                             //
//  TFndPreanMan could be used directly, by the way this class simplify the    //
//  run-processing: three run-processing modes are available:                  //
//          1) standard mode:                                                  //
//               Increasing run-number (first-run < last-run)                  //
//                                                                             //
//          2) reverse mode:                                                   //
//               Decreasing run-number (first-run > last-run)                  //
//                                                                             //
//          3) DAQ-follow mode:                                                //
//               A check of the last acquired run is performed, in order to    //
//               follow the DAQ, without the need of users interacation        //
//                                                                             //
//  Pre-analysis log files and benchmarks are also provided by this class.     //
//                                                                             //
//  This class is directly used by the "PreanProcFinuda" executable            //
//  (official pre-analysis producer)                                           //
//                                                                             //

#include "TFndPreanProcess.h"


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(){

  Info("~TFndPreanProcess","Destroying the preanalysis manager");
  delete fPreanMan;
}

//___________________________________
void TFndPreanProcess::InitPreanalysis(){
  
  if(fPreanMan){
    Error("InitPreanalysis","fPreanMan should not be defined yet!");
    delete fPreanMan;
    TerminateFroot();
  }
  fPreanMan = new TFndPreanMan(fDBhost,fDataPath,fDebugLevel);
}

//___________________________________
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
  

  InitPreanalysis();

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

---