PREAN/TFndPreanMan.cxx

// @(#)fROOT/PREAN:$Name:  $:$Id: TFndPreanMan.cxx,v 1.57 2007/10/04 14:10:26 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2005/06/24

//  This class is designed in order to manage any preanalysis process          //
//  based or not on the FINUDA official reconstruction code.                   //
//  You should never use more than one object of this class within the         //
//  same preanalysis process (even if you are performing a loop on             //
//  several runs).                                                             //
//                                                                             //
//  The Preanalysis-Manager is written to work both in online and offline      //
//  mode, depending on the arguments passed to the InitNewPreanRun() method:   //
//            ===> (0,0) means online (default arguments)                      //
//            ===> ("FINU",10) means offline processing of FINU00010.raw       //
//                             (both arguments must be specified)              //
//                                                                             //
//  You can call InitNewPreanRun() only if no other process is running, i.e.   //
//  you need to call FinishRun() first; the access to  InitNewPreanRun() and   //
//  is controlled through the fProcessing data member.                         //
//                                                                             //
//  The fidarc<->froot interface is handled by the TFndProcessRec class        //
//  through the fProcessRec data member; the main addresses for ZEBRA banks    //
//  access are stored (and re-initialized by InitNewPreanRun()) in the         //
//  fJFGES and fJFDST data members.                                            //
//  Debug on TFndProcessRec is "hard coded"                                    //
//  ("processrec_debug" in the source code of the "InitNewPreanRun" method)    //
//                                                                             //
//                                                                             //
//  The SINGLE-EVENT-PREANALYSIS is splitted into three steps:                 //
//     1) - Get raw event (in FROOT code) and perform pre-analysis             //
//           (eventually you can perform also a custom analysis)               //
//     2) - raw event --=> zebra --=> reconstructed hits                       //
//        - ROOT event reconstruction from JFGES (AnalyzeJFGES() method)       //
//     3) - fidarc standard reconstruction                                     //
//        - ROOT zebra-dst analysis from JFDST (AnalyzeJFDST() method)         //
//  NOTE: the ROOT-dst tree is completely independent on the pre-analysis.     //
//                                                                             //

#include <limits>
#include <TROOT.h>
#include <TSystem.h>
#include <TApplication.h>
#include <TMath.h>
#include <TThread.h>

#include "TFndProcessRec.h"
#include "TFndPrean.h"
#include "TFndPreanHistos.h"
#include "TFndEnv.h"
#include "TFndPreanMan.h"

ClassImp(TFndPreanMan)

//_____________________________
TFndPreanMan::TFndPreanMan(TString msqlhost, TString data_path, Int_t debug_lev)
: TFndRun(),
  fNumOfProcessedFidaEvents(), fJFGES(), fJFDST(), fCurPreanFile()
{
  TFndEnv *env = TFndEnv::Instance();

  // Check existence of needed files (fida*.dat; fida*.so; etc...)
  fDebug = debug_lev;
  fMaxNofEvents = std::numeric_limits<Int_t>::max();
  
  if (msqlhost) fDBHost = ExpandPathName(msqlhost);
  else fDBHost = env->GetValue("froot.PreAnalysisManager.MsqlDbHost", "localhost", "MSQL_DB_HOST");

  if (data_path) fDataPath = data_path;
  else fDataPath = env->GetValue("froot.PreAnalysisManager.DataPath", "/data01", "RDT");

  fPrean = new TFndPrean(debug_lev);    // Preanalysis calculations
  fPrean->SetDeamonBehaviour();
}

//_____________________________
TFndPreanMan::~TFndPreanMan(){

  delete fProcessRec; // why not?
  delete fPrean;
}


//_____________________________
Int_t TFndPreanMan::CloseInterface(){
  // close shared libraries and delete fProcessRec
  // (fProcessRec is also resetted in order to allow deletion in dtor)
  // this method must be called before dtor
  // return value: exit code of the "dlclose" function

  if(!fProcessRec) return 0;
  Int_t dlclose_err = fProcessRec->CloseInterface();
  delete fProcessRec; fProcessRec = 0;
  return dlclose_err;
}

//_____________________________
Int_t TFndPreanMan::InitNewPreanRun(TString runtype,Int_t runnum){
  // initialize interface for new run (default: online)
  
  Int_t ret_val = InitNewRun(runtype,runnum,kTRUE); // skip TFndRun event management
  if(ret_val) return ret_val;

  if(fOnlineFlag == ONL_ALL) fPrean->Init(kTRUE); 
  else fPrean->Init(kFALSE);

  if(fDebug) Info("InitNewPreanRun", "...initializing fidarc...");
  Bool_t processrec_debug = kFALSE;
  if (!fProcessRec) {
    if(processrec_debug) Printf("creating new process_rec");
    fProcessRec = new TFndProcessRec(fRunType.Data(), fRunNumber, fDataPath.Data(), fDBHost.Data(), processrec_debug);
  }
  else {
    if(fProcessRec->GetDebugFlag()) Printf("using existing process_rec");
    fProcessRec->InitNewRun(fRunType.Data(), fRunNumber, fDataPath.Data(), fDBHost.Data(), processrec_debug);
  }
  if(!fProcessRec) TerminateFroot(0,"TFndPreanMan::InitNewPreanRun ---> fProcessRec not available");
  
  if(fDebug) Info("InitNewPreanRun", "...fidarc initialized successfully.");

  return ret_val;
}

//_____________________________
Int_t TFndPreanMan::FinishPreanRun(Bool_t last,Bool_t create_outfile){
  // reset interface and data members
  // in case of last run the interface is also closed
  // 
  // Current root-file with pre-analysis trees is closed
  // fPrean members are not reset until a new run is initialized
  
  TString runtype = fRunType; // will be reset by TFndRun::FinishRun
  Int_t runnum = fRunNumber;  // will be reset by TFndRun::FinishRun

  Int_t ret_val = FinishRun(last,kTRUE); // skip TFndRun close operations
  if(ret_val) return ret_val; // stop method here in case of errors
  
  fJFGES = 0;
  fJFDST = 0;
  
  if(!fProcessRec){
    Error("FinishRun", "The process seems to be running without fProcessRec");
    return -1;
  }

  if(fDebug) Info("FinishRun", "Closing run in fProcessRec (is last: %u)",last);
  fProcessRec->CloseRun(last);

  // --- create output file and save  
  if(create_outfile){
    TString cpth = "$FND_PREAN_TREES/";
    cpth+=FIN_PHYS::FidaVer_Name();
    TString start_pth=ExpandPathName(cpth);  
    
#if defined _FND_OUTPUTS_USE_SUBDIR
    CreateGrpSubDir(runtype,runnum,start_pth);
    TString frunnam = BuildRunName(runtype,runnum,kTRUE);
#else
    TString frunnam = BuildRunName(runtype,runnum);
#endif
    
    TString fnam;
    fnam.Form("%s/%s.prean.root",
              start_pth.Data(),
              frunnam.Data() );
    
    fCurPreanFile = new TFile(fnam,"RECREATE");
    fCurPreanFile->SetCompressionLevel(1);
    if( fPrean->SaveTrees(fCurPreanFile) != -1 ){
      fCurPreanFile->Close();
      delete fCurPreanFile;
      fCurPreanFile = 0;
    }
  }
  // ---
  if(last){
    fPrean->Finish(); // perform ending preanalysis operations at the end of the last run
    fNumOfProcessedFidaEvents = 0;
    CloseInterface();
  }
  return ret_val;
}

//_____________________________
// UInt_t TFndPreanMan::UpdateScalers(){
//   // the elepsed time from last update is returned

//     if (fDebug) Info("EvalLuminosity","Scalers Event number %u",GetEvNum_Raw());
//     fPrean->ReadScalers(fRawEvent);
// }

//_____________________________

// Int_t TFndPreanMan::EvalLuminosity(Int_t Lumin){
//   // pre-analysis of the current raw event (ROOT)
//   // arguments:
//   //        - Scalers: true ==> Read scalers and text-files generation enabled
//   //        - Lumin  : bit-mask for evaluation methods
//   //                   1 (LUMIN_BHABHA)  ==> Bhabha lumin evaluation method
//   //                   2 (LUMIN_KPKM)    ==> K+/K- lumin evaluation method
//   //                   4 (LUMIN_KLKS)    ==> KL/KS lumin evaluatino method
//   //                   7 (LUMIN_DEFAULT) ==> All above methods combined (default)
//   //
//   // this method has been re-written by H. So (July 2006)
  
//   if(Lumin == LUMIN_NONE){
//     Warning("EvalLuminosity","No method has been selected: nothing will happen...");
//     return 0;
//   }
//   if(fProcessRec->GetBhabhaRecMode() != TFndProcessRec::E_SINGLE_HELIX){
//     Warning("EvalLuminosity","Are you sure you want to use double-helix procedure for bhabha events?");
//     gSystem->Sleep(500);
//   }
  
  
//   if (Lumin & LUMIN_UNUSED) Warning("EvalLuminosity", "unused bits are on (0x%x)\n", Lumin);
//   if (Lumin & LUMIN_BHABHA) fPrean->EvalLuminBhabha(fProcessRec);
//   if (Lumin & LUMIN_KPKM)   fPrean->EvalLuminKPKM(fProcessRec);
//   if (Lumin & LUMIN_KLKS)   fPrean->EvalLuminKLKS(fProcessRec);

//   /*
//     finuda_lum.fast and raw format:
    
//     | from epoch (unix time) |
//     | to epoch (unix time) |
//     | time bin size (seconds) |   // may be removed
//     | instantaneous luminosity from bhabha (10^33 cm-2 s-1) |
//     | instantaneous luminosity from K_short (10^33 cm-2 s-1) |
//     | instantaneous luminosity from K stopped (10^33 cm-2 s-1) |
//     | instantaneous luminosity integrated over 60 s (nbarn) | // to be understood
//     | luminosity integrated over the time of the experiment (nbarn) | // to be understood
//     | momentum mean value (GeV/c) |
//     | momentum st dev (GeV/c) |
//     | X mean value (cm) |
//     | X st dev (cm) |
//     | Z mean value (cm) |
//     | Z st dev (cm) |
//     | triggered events |
//     | analyzed events |
//     | reconstructed evented |
//     | recognized bhabha events |
//     //
//     //
//     //                            (recognized bhabha events * triggered events)
//     //                            ---------------------------------------------
//     //                                 (analyzed events * time bin size)
//     Instantaneous Luminosity = -------------------------------------------------
//     //                                     cross section * efficiency
    
//     finuda_point.fast:
    
//     | Mom value | X value | Z value |
//   */
//   return 0;
// }


//_____________________________
Int_t TFndPreanMan::GetNextFidaEvent()
{
  // --- fidarc event management (read_lib and JFGES zebra)
  //
  // return value:
  //              0 -> good event
  //              1 -> run completed

  fNumOfProcessedFidaEvents++;
  if (fDebug) Info("GetNextFidaEvent", "getting fida event %d (local counter)", fNumOfProcessedFidaEvents);
  Int_t FidaResult = 0;

  fPrean->ResetDataVariables();

  FidaResult = fProcessRec->FillJFGES();
  if (fNumOfProcessedFidaEvents == 1)
    fProcessRec->SetRuninf();   // set the common address one time only
  fJFGES = fProcessRec->GetJFGES();
  fJFDST = 0;                   // contains data relative to the previous event

  bzero(fRawEvent,sizeof(fRawEvent));
  memcpy(fRawEvent, fProcessRec->GetRawEvPointer(), sizeof(fRawEvent));
  //  fRawEvent = fProcessRec->GetRawEvPointer();
  return FidaResult;
}

//_____________________________
Int_t TFndPreanMan::ReconstructFidaEvent(){
  // process fidarc reconstruction
  // and fill JFDST zebra banks
  // (thus loosing informations in JFDST)
  // This method must be called only if GetNextEvent()
  // was called previousely
  //
  // return value:
  //               0 -> good event
  //               1 -> run completed
  //              -1 -> problems

  Int_t result = fProcessRec->Reconstruct();
  fJFDST = fProcessRec->GetJFDST();
  fJFGES = 0; // not useful anymore (banks dropped by fidarc reconstruction)
  return result;
}

// //_____________________________
// void TFndPreanMan::InitHistos(){
//   // initialize fHistos and build histograms

//   if (fDebug) Info("InitHistos", "Initializing histograms");
//   fHistos = new TFndPreanHistos(fDebug);
//   fHistos->BuildHistos();
//   if (fDebug) Info("InitHistos", "done");
// }

//_____________________________
void TFndPreanMan::AnalyzeJFGES(){
  // analyze JFGES zebra banks before processing fidarc event reconstruction
  // call this method only after GetNextEvent() and before ReconstructEvent()

  fPrean->ReadScalers(fRawEvent); // fidarc not involved
  fPrean->InspectGES(fProcessRec);
  fPrean->CheckTofinoCFDs(fProcessRec);
}

//_____________________________
void TFndPreanMan::AnalyzeJFDST(){
  // analyze JFDST zebra banks
  // call this method only after ReconstructEvent()
 
  fPrean->AnalyzeBhabha(fProcessRec);
  fPrean->AnalyzeHype(fProcessRec);
  fPrean->UpdateGESTree();

}

//_______________________________________________________________________
void TFndPreanMan::OpenLogFile(const TString &fdir, const TString &fnam){

  CloseLogFile();

  TString path_str;
  path_str.Form("%s/%s",ExpandPathName(fdir).Data(),fnam.Data());

  fCurLogFile = new ofstream();

  fCurLogFile->open(path_str.Data(),ofstream::out | ofstream::app);

  fPrean->SetLogFile(fCurLogFile);
}

---