mcr_included/AccessZebra_MultiRun.C

#ifndef FROOT_ZEBRA_ACCESS
#define FROOT_ZEBRA_ACCESS

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

#include "TString.h"
#include "TObject.h"

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


class TZebraAccess: public TObject{
  
private:
  TFndProcessRec *fPrec;
  
  TFndPreanMan *fPreanMan;
  
  Bool_t fFillDst;

  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;
  
public:

  TZebraAccess();
  ~TZebraAccess();

  virtual void Init(const TString &db_host,const TString &data_path,const TString &run_type,Int_t first_run,Int_t last_run,Int_t n_evs_run,Int_t n_evs_tot,Int_t debug_lev);

  virtual void SetFillDst(const Bool_t &fill_dst) { fFillDst = fill_dst; }

  virtual void UseProcessRec_GES()=0;
  virtual void UseProcessRec_DST()=0;
  virtual void EventLoop();
  virtual Int_t ProcessSingleRun();
  virtual Int_t RunLoop();

  virtual void Pre_Run_Operation() = 0;
  virtual void Post_Run_Operation() = 0;

  //  ClassDef(TZebraAccess,1)
};

#endif // FROOT_ZEBRA_ACCESS

//ClassImp(TZebraAccess)

//___________________________________
TZebraAccess::TZebraAccess():
  fPrec(),fPreanMan(),
  fFillDst(),fDBhost(),fDataPath(),fRunType(),
  fFirstRun(),fLastRun(),fDebugLevel(),
  fTotEvCount(),fTotEvTgt(),fEvPerRunTgt(),
  fCurEv(),fIncrement(),fCurrentRun()
{
  
  fFillDst = kTRUE;
}

//___________________________________
TZebraAccess::~TZebraAccess(){
  //  cout << "DEBUG1" << endl;
  delete fPreanMan;
  //  cout << "DEBUG2" << endl;
}

//___________________________________
void TZebraAccess::Init(const TString &db_host,const TString &data_path,const TString &run_type,Int_t first_run,Int_t last_run,Int_t n_evs_run,Int_t n_evs_tot,Int_t debug_lev){
  
  fDBhost = db_host;
  fDataPath = data_path;
  fRunType = run_type;
  fEvPerRunTgt = n_evs_run;
  fTotEvTgt = n_evs_tot;
  fDebugLevel = debug_lev;
  //
  fFirstRun = first_run;
  fLastRun = last_run;
  //
  fPreanMan = new TFndPreanMan(fDBhost,fDataPath,fDebugLevel);
}

//___________________________________
void TZebraAccess::EventLoop(){
  
  fPrec = fPreanMan->GetProcessRec();
  if(!fPrec) TerminateFroot(0,"fPrec not available!");

  while(1){
    if( fCurEv % 300 == 0 ) gROOT->Info("EventLoop","Processing run %s-%d ===> event %d",fRunType.Data(),fCurrentRun,fCurEv);
    if(fTotEvTgt != -1 && fTotEvCount > fTotEvTgt){
      Printf("EventLoop ---> maximum number of events reached for current preanalysis process");
      return;
    }
    if(fEvPerRunTgt != -1 && fCurEv > fEvPerRunTgt){
      Printf("EventLoop ---> maximum number of events reached for current run");
      return;
    }
    if( fPreanMan->GetNextFidaEvent() != 0) return; // Fill FGES
    UseProcessRec_GES();
    //    fPreanMan->AnalyzeJFGES(); // used by pre-analysis
    
    if(fFillDst){
      if( fPreanMan->ReconstructFidaEvent() !=0) return; // Fill FDST (exit loop in case of problems)
      UseProcessRec_DST();
      //    fPreanMan->AnalyzeJFDST(); // used by pre-analysis
    }

    fCurEv++;
    fTotEvCount++;
  } // event loop completed
  
}

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

  Pre_Run_Operation();

  Int_t initval = fPreanMan->InitNewPreanRun(fRunType,fCurrentRun); // offline mode
  if(initval!=0){
    //      Printf("initval: %d",initval);
    fPreanMan->FinishPreanRun(kFALSE,kFALSE);
    fCurrentRun += fIncrement;
    Printf("\n --- --- --- --- \n"); // simply nice ;)
    return -1;
  }
  
  Printf("New run started (%s %d)",fRunType.Data(),fCurrentRun);
  
  fCurEv = 1; // reset single run event counter
  
  // ---
  EventLoop();
  // ---
  
  fPreanMan->FinishPreanRun(fIsLastRun,kFALSE); // last run completed
  
  Printf("\n --- --- --- --- \n"); // simply nice ;)

  Post_Run_Operation();
  
  return 0;
}

//___________________________________
Int_t TZebraAccess::RunLoop(){
  
  if(!fPreanMan){
    gROOT->Error("RunLoop","fPreanMan not defined");
    TerminateFroot();
  }

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

  fCurrentRun = fFirstRun;
  fIncrement = (fLastRun >= fFirstRun) ? +1 : -1;
  
  while(1){ // run loop
    //    cout << "DEBUG 0 ===> " << fCurrentRun << endl;

    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
  
  //  cout << "DEBUG 1" << endl;
  fPreanMan->CloseInterface(); // close used reconstruction (dynamic) library
  //  cout << "DEBUG 2" << endl;
  
  return 0;
  
}

//___________________________________
//___________________________________
//___________________________________
// void AccessZebra_MultiRun(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){
  
//   TZebraAccess *zac = new TZebraAccess();
//   // --- INIT ---
//   Int_t debug_lev = 0;
//   //
//   zac->Init("$MSQL_DB_HOST","$RDT",run_type,first_run,last_run,n_evs_run,n_evs_tot,debug_lev);
  

//   zac->RunLoop();
//   delete zac;
// }

---