mcr_included/AccessHDT_MultiRun.C

#ifndef FROOT_HDT_ACCESS
#define FROOT_HDT_ACCESS

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

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

#include "TFndHdt.h"


class THdtAccess: public TObject{
  
private:

  Int_t fVerboseLevel; // verbose level (default: 1)
  Int_t fUpdateEvGap; // default : 300

  TFile *fCurHdtFile;
  TTree *fCurHdtTree;
  TFndGenInfo *fCurRunInfo;

  TFndHdt *fCurHdtEv;

  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;
 
  Int_t fCurTotEntries; // total number of entries in current tree

  Int_t InitNewRun();
  Int_t FinishRun();

public:

  THdtAccess();
  ~THdtAccess();

  void SetUpdateEvGap(const Int_t &ev_gap) { fUpdateEvGap = ev_gap; }
  Int_t GetUpdateEvGap() { return fUpdateEvGap; }

  void SetVerboseLevel(const Int_t &lev) { fVerboseLevel = lev; }
  Int_t GetVerboseLevel() { return fVerboseLevel; }

  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 UseHdtEvent()=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(THdtAccess,1)
};

#endif // FROOT_HDT_ACCESS

//ClassImp(THdtAccess)

//___________________________________
THdtAccess::THdtAccess():
  fVerboseLevel(1),fUpdateEvGap(300),
  fCurHdtFile(),fCurHdtTree(),fCurRunInfo(),
  fCurHdtEv(),
  fDBhost(),fDataPath(),fRunType(),
  fFirstRun(),fLastRun(),fDebugLevel(),
  fTotEvCount(),fTotEvTgt(),fEvPerRunTgt(),
  fCurEv(),fIncrement(),fCurrentRun(),fCurTotEntries()
{
  
}

//___________________________________
THdtAccess::~THdtAccess(){

}

//___________________________________
void THdtAccess::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;
  //
  fCurTotEntries = 0;
}


//___________________________________
Int_t THdtAccess::InitNewRun(){
  // return value:
  //               0: ok
  //              -1: error (hdt-file not found, or not ready)
  //              -2: error (hdt-tree not found inside hdt-file)
  //              -3: warning (hdt-tree found and got, but empty)
  //              -4: error (can not assign HDT-branch from hdt tree)
  //              -5: error (can not get run-info pointer)

  if(fVerboseLevel > 2) Printf("InitNewRun: fCurrentRun = %u",fCurrentRun);
  
  FinishRun(); // not relly needed but safe
  
  // --- get file
#if defined _FND_OUTPUTS_USE_SUBDIR
  TString hdt_rnam = BuildRunName(fRunType,fCurrentRun,kTRUE);
#else
  TString hdt_rnam = BuildRunName(fRunType,fCurrentRun);
#endif
  
  hdt_rnam+=".hdt.root";
  TString cpth = "";
  cpth.Form("%s/%s",ExpandPathName("$FND_HDT").Data(),hdt_rnam.Data());

  if( gSystem->AccessPathName(cpth) ){
    Printf("file \"%s\" not found",cpth.Data());
    return -1;
  }
  //  Printf("Opening file \"%s\"",cpth.Data());
  fCurHdtFile = new TFile(cpth,"OPEN");
  if(!fCurHdtFile){ // not relly needed but safe
    Printf("problems while trying to get file \"%s\"",cpth.Data());
    return -1;
  }
  //  fCurHdtFile->ls();

  // --- get tree
  fCurHdtTree = (TTree *) ( fCurHdtFile->Get("FIN_HDT_TREE") );
  if(!fCurHdtTree){
    Printf("tree \"FIN_HDT_TREE\" not found in file \"%s\"",fCurHdtFile->GetName());
    return -2;
  }
  if(fCurHdtTree->GetEntries() < 1){
    Printf("tree \"FIN_HDT_TREE\" found, but empty");
    return -3;
  }
  //fCurHdtTree->Print();

  // --- assign HDT branch
  if(! fCurHdtTree->GetBranch("fndhdt") ){
    Printf("can not assign HDT-branch from hdt tree");
    return -4;
  }
  fCurHdtTree->SetBranchAddress("fndhdt",&fCurHdtEv);
  fCurTotEntries = fCurHdtTree->GetEntries();

  
  // --- get run-info
  fCurRunInfo = (TFndGenInfo *)( fCurHdtFile->Get("TFndGenInfo") );
  if(!fCurRunInfo){
    Printf("Pointer to TFndGenInfo not found in file \"%s\"",fCurHdtFile->GetName());
    return -5;
  }
  
  return 0;
}

//___________________________________
Int_t THdtAccess::FinishRun(){
  // return value: 
  //              0: normal condition
  //              1: nothing to do

  if(fVerboseLevel > 2) Printf("FinishRun: fCurrentRun = %u",fCurrentRun);

  if(!fCurHdtFile && !fCurHdtTree && !fCurHdtEv  ){
    //    Printf("THdtAccess::FinishRun ---> Nothing to do");
    return 1;
  } 

  if(fCurHdtEv){
    delete fCurHdtEv;
    fCurHdtEv = 0;
  }
  if(fCurHdtTree){
    fCurHdtTree->Reset();
    delete fCurHdtTree;
    fCurHdtTree = 0;
  }

  if(fCurRunInfo){
    delete fCurRunInfo;
    fCurRunInfo = 0;
  }


  if( fCurHdtFile ){
    if( fCurHdtFile->IsOpen() ) fCurHdtFile->Close();
    delete fCurHdtFile;
    fCurHdtFile = 0;
  }

  fCurTotEntries = 0;

  return 0;
}

//___________________________________
void THdtAccess::EventLoop(){

  while(1){
    if(fCurEv > fCurTotEntries){
      if(fVerboseLevel > 0) Printf("EventLoop ---> run completed (%d events)",fCurEv-1);
      return;
    }
    else{
      if(fTotEvTgt != -1 && fTotEvCount > fTotEvTgt){
        if(fVerboseLevel > 0) Printf("EventLoop ---> maximum number of events reached for current process");
        return;
      }
      if(fEvPerRunTgt != -1 && fCurEv > fEvPerRunTgt){
        if(fVerboseLevel > 0) Printf("EventLoop ---> maximum number of events reached for current run");
        return;
      }
    }
    //
    if( fCurEv % fUpdateEvGap == 0 && fVerboseLevel > 0 )
      gROOT->Info("EventLoop","Processing run %s-%d ===> event %d",fRunType.Data(),fCurrentRun,fCurEv);
    //

    fCurHdtTree->GetEntry(fCurEv-1);
    UseHdtEvent();

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

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

  Pre_Run_Operation();

  Int_t initval = InitNewRun();
  if(initval!=0){
    Printf("initval: %d",initval);
    FinishRun();
    return -1;
  }
  
  if(fVerboseLevel > 1) Printf("New run started (%s %d)",fRunType.Data(),fCurrentRun);
  
  fCurEv = 1; // reset single run event counter
  
  // ---
  EventLoop();
  // ---
  Post_Run_Operation();
  FinishRun();
  if(fVerboseLevel > 1) Printf("\n --- --- --- --- \n"); // simply nice ;)
  
  return 0;
}

//___________________________________
Int_t THdtAccess::RunLoop(){
  // return value: number of skipped runs

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

  Int_t retval = 0;

  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 process");
      break;
    }
    
    fIsLastRun = (fCurrentRun == fLastRun)? kTRUE : kFALSE;
    if(ProcessSingleRun() == -1){
      fCurrentRun += fIncrement;
      retval++;
      continue;
    }
    //    
    if(fCurrentRun == -1) break; // one initialization only in online-mode
    //

    //
    fCurrentRun += fIncrement;
  } // run loop completed
  
  return retval;
  
}

---