STEER/TFndRun.cxx

// @(#)fROOT/STEER:$Name:  $:$Id: TFndRun.cxx,v 1.92 2007/09/24 07:32:41 Diego_Faso Exp $
// Revision Author: Diego Faso <mailto:faso@to.infn.it>, 2005/06/24
// Original Author: P. Cerello <mailto:cerello@to.infn.it>, 2000

//                                                               //
//  Control class for FINUDA C++ run processing                  //
//  Only one single instance of this class exists.               //
//  The object is pointed by the global fndrun.                  //
//                                                               //
//   -Supports the list of all FINUDA Detectors (fDetectors).    //
//                                                               //
//                                                               //
//Begin_Html
//  <img src="../froot_images/fnd_logo.gif">
//End_Html
//                                                               //

//#include "FROOT.h"
#include "TFndRun.h"

#include "TFndGtsMon.h"
#include "TFndTofMon.h"
#include "TFndSilMon.h"
#include "TFndLmdMon.h"
#include "TFndStbMon.h"

// socket includes management depends on CINT
#if defined(__CINT__)
#include <netinet/in.h>
#endif
#include <sys/ioctl.h>
#include <sys/socket.h>
// ---

#include "msql.h" // to be removed as soon as possible

#include "Bytes.h"

TFndRun *fndrun = 0;

ClassImp(TFndRun)

TFndHdt *TFndRun::fgFinHdt = 0;
//___________________________________________
TFndRun::TFndRun(const TString &name, const TString &title):
  TNamed(name,title)
{
  // default constructor:
  
  if(fndrun){// only 1 object of TFndRun allowed
    Error("TFndRun", "cannot create 2 objects of TFndRun!");
    TerminateFroot();
  }
  // --- initialization to be optimized
  fRunConfiguration = 0;
  fFeeMap = 0;

  fGenInfo = 0;

  fGtsMonFrame = 0;
  fTofMonFrame = 0;
  fSilMonFrame = 0;
  fLmdMonFrame = 0;
  fStbMonFrame = 0;

  fGtsMon = 0;
  fTofMon = 0;
  fIsmMon = 0;
  fOsmMon = 0;
  fLmdMon = 0;
  fStbMon = 0;
  
  fProcessRec = 0;
  // ---------------------
  
  fFinRdt = 0;
  if(name.IsNull()) SetName(name);  
  if(title.IsNull()) SetTitle(title);  

  Init();
}

//___________________________________________
TFndRun::~TFndRun(){

  if (fndrun != this) fndrun = this;

  Info("~TFndRun","Cleaning memory in TFndRun...");
  delete fRunConfiguration;
  delete fFeeMap;
  delete fGenInfo;


  Info("~TFndRun","Deleting monitor producers");
  Info("~TFndRun"," (GTS)");
  delete fGtsMon;
  Info("~TFndRun"," (TOF)");
  delete fTofMon;
  Info("~TFndRun"," (ISM)");
  delete fIsmMon;
  Info("~TFndRun"," (OSM)");
  delete fOsmMon;
  Info("~TFndRun"," (LMD)");
  delete fLmdMon;
  Info("~TFndRun"," (STB)");
  delete fStbMon;

  if(fOnlineFlag == ONL_OFF){
    Info("~TFndRun","Deleting monitor consumers");
    delete fGtsMonFrame;
    delete fTofMonFrame;
    delete fSilMonFrame;
    delete fLmdMonFrame;
    delete fStbMonFrame;
  }
  
  Info("~TFndRun","Deleting hits buffers");
  delete fFinRdt;
  delete fFinHdt;

  fndrun = 0;

  //  delete fProcessRec; // handled by TFndPreanMan
  Info("~TFndRun","Memory allocated for TFndRun cleaned.");

}

//___________________________________________
Int_t TFndRun::Init(){
  // private method called by ctors
  // (some operations are shared between different constructors)

  fndrun = this;
  fRunConfiguration = new TFndRunConfiguration(); 

  fIsNewRun = kFALSE;
  SetDBHost("$MSQL_DB_HOST");
  SetDataPath("$RDT");
  fMaxNofEvents = std::numeric_limits<Int_t>::max();

  fFeeMap = new TFndFeeMap();
  fRunTypeID == -1;
  fNumOfProcessedRuns = 0;
  fNumOfProcessedEvents = 0;

  fGenInfo = new TFndGenInfo();

  fSockLength = FIN_RAW_DATA_SOCK_LEN;
  request_counter = 0;
  fUdpSd = -1; // means error
  
  if (!fgFinHdt) fgFinHdt = new TFndHdt();
  fFinHdt = fgFinHdt;
  //  fFinHdt = new TFndHdt();
  fFinRdt = new TFndRdt();

  fCurLogFile = 0;
  for(Int_t i= (Int_t)D_GTS; i<= (Int_t)D_STB; i++) fMustFillMonitor[i] = kTRUE;

}

//_____________________________
Int_t TFndRun::InitNewRun(TString runtype,const Int_t &runnum,const Bool_t &UsedByPrean){
  // return values:
  //                -  1: nothing to do: some other process is running
  //                -  0: ok (can start process)
  //                - -1: raw file not found (or not stat'ed - see TSystem::GetPathInfo -)
  //                - -2: raw file too little
  //                - -3: user error (wrong run type, etc...)
  //
  // NOTE: while using TFndPreanMan only the 
  //       following return value are possible:
  //                -  1: nothing to do: some other process is running
  //                -  0: ok (can start process) (not checking "-1" and "-2" cases)
  //                - -3: user error (wrong run type, etc...)
  //
  // maybe a check on run type/number should be added:
  // (now it is possible to make mistakes calling ONLM00000 and so running offline
  //  while the user thinks to run online...)

  fRunNumber = runnum;
  fGebIp = FROOT::Ip2Int(gSystem->Getenv("FND_GEBIP"));

  if (fProcessing) {
    Warning("InitNewRun", "Nothing to do: already processing");
    return 1;
  }

  if(SetRunType(runtype) == -1) return -3;
  
  if(!UsedByPrean){ // note that this is the default behaviour
    Info("InitNewRun", "New process starting");
    
    // raw-file/socket raw event management
    if (runnum == -1) {             // ONLINE MODE
      Info("InitNewRun", "Initializing new run in online mode");
      fOnlineFlag = ONL_ALL;
      fRunType = "ONLM";       // override any other name (maybe it is better to chek previousely)
      RecreateSocketToDAQ();
    }
    else {                          // OFFLINE MODE
      fOnlineFlag = ONL_OFF;
      
      fRunFilename =  BuildRunName(fRunType,fRunNumber);
      Info("InitNewRun", "Initializing new run in offline mode (run \"%s\")",fRunFilename.Data());
      Long_t raw_file_size = OpenRawFile(fDataPath, fRunFilename);
      if (raw_file_size == -1) {
        if(fDebug) Error("InitNewRun", "raw file not found");
        return -1;
      }
      else if (raw_file_size < k_MinRawFileSize) {
        Error("InitNewRun", "raw file too small (%ld)", raw_file_size);
        return -2;
      }
    }
  }
  else{ // performed when called by TFndPrean (daughter)
    if (runnum == -1) {             // ONLINE MODE
      Info("InitNewRun", "Initializing new run in online mode");
      fOnlineFlag = ONL_ALL;
      fRunType = "ONLM";
    }
    else { // OFFLINE MODE
      fOnlineFlag = ONL_OFF;
      
      fRunFilename =  BuildRunName(fRunType,fRunNumber);
      Info("InitNewRun", "Initializing new run in offline mode (run \"%s\")",fRunFilename.Data());
      Long_t raw_file_size = OpenRawFile(fDataPath, fRunFilename,kTRUE); // do not open file
      if (raw_file_size == -1) {
        if(fDebug) Error("InitNewRun", "raw file not found");
        return -1;
      }
      else if (raw_file_size < k_MinRawFileSize) {
        Error("InitNewRun", "raw file too small (%ld)", raw_file_size);
        return -2;
      }
    }
  }
  
  // --- it is safe to check here the online flag
  if(fOnlineFlag < (Int_t)(ONL_OFF) || fOnlineFlag > (Int_t)(ONL_ALL)){
    Error("GetNextRawEvent","You have just found a BUG! (fOnlineFlag = %d)",fOnlineFlag);
    TerminateFroot(0,"BUG detected: Requested online flag value not available");
  }
  
  fCurRunType = "";
  fCurRunNum = 0;
  fIsNewRun = kTRUE;
  fProcessing = kTRUE;  
  fNumOfProcessedRuns++;
  return 0;
}

//_____________________________
Int_t TFndRun::FinishRun(Bool_t last,const Bool_t &UsedByPrean){
  // reset interface and data members
  // if "last=true" close fortran (can not restart!)
  // return values:
  //                -  1: nothing to do: some other process is running
  //                -  0: ok
  //                - -1: error
  //
  // Init/Finish process tested up to 3000 times

  if(!fProcessing){
    if(fDebug) Warning("FinishRun", "Nothing to do: no process running");
    return 1;
  }

  if(fOnlineFlag){
    Info("FinishRun", "Terminating online process");
    ShutdownSocketToDAQ();
  }
  else{
    Info("FinishRun", "Terminating process for run \"%s\" number %d", fRunType.Data(), fRunNumber);
    if(fRawFile) fclose(fRawFile);
  }

  fRunNumber = 0;

  fProcessing = kFALSE; // now ready to restart
  
  if(!UsedByPrean){
    if(fDebug) Info("FinishRun", "performing end-of-run operations.");
    WriteMonitors(kTRUE);
  }
  
  if (!last){
    Info("FinishRun", "Current run completed: ready to start a new run.");
  }
  else{
    Info("FinishRun", "Process terminated: performing end-of-process operations.");
    fNumOfProcessedRuns = 0;
    fNumOfProcessedEvents = 0;
    CleanEvent();
  }
  
  return 0;
}

//___________________________________________
Int_t TFndRun::SetRunType(TString runtype){
  // return value:
  //              0: ok
  //             -1: selected run type not available

  //  Info("SetRunType","received string: \"%s\"",runtype.Data());
  fRunTypeID = -1; 
  for(Int_t i=(Int_t)(RT_FINU);i<=(Int_t)(RT_ONLM);i++){
    if((Int_t)(runtype.CompareTo(RunType_Name(i))) == 0){ fRunTypeID = i;  break; }
  }
  if(fRunTypeID == -1){
    Warning("SetRunType","runtype \"%s\" not accepted",runtype.Data());
    fRunType = "";
    return -1;
  }
  fRunType = runtype;
  //  Info("SetRunType","setting completed: fRunType = \"%s\", fRunTypeID = %d",fRunType.Data(),fRunTypeID);
  return 0;
}
//___________________________________________
void TFndRun::SetRunType(Int_t runtype){

  if(runtype>(Int_t)(RT_ONLM)) Warning("SetRunType","runtype %d not accepted",runtype);
  fRunTypeID = runtype;
  fRunType = RunType_Name(runtype);
}

//___________________________________________
void TFndRun::ClearEvent(){
  // method called at the end of every processed event
  
  if(fDebug){
    cout << "TFndRun::ClearEvent Info: Clearing event " << endl;
    cout << "TFndRun::ClearEvent Info: rdt: " << fFinRdt << endl;
  }  
  fFinRdt->Reset();
  fFinHdt->Reset();

  //  if(fOnlineFlag = ONL_OFF && fRawEvent != 0) { delete [] fRawEvent; fRawEvent = 0; }
  bzero(fRawEvent,sizeof(fRawEvent));
  //  if(fRawEvent != 0) { delete [] fRawEvent; fRawEvent = 0; }

  if(fDebug) cout << "TFndRun::ClearEvent Info: Event cleared" << endl;
}

//___________________________________________
void TFndRun::CleanEvent(){
  // method called at the end of event processing
  // this method is 'protected' since it is needed only at the end
  // of every processed run.

  if(fDebug){
    cout << "TFndRun::CleanEvent Info: Cleaning event " << endl;
    cout << "TFndRun::CleanEvent Info: rdt: " << fFinRdt << endl;
  }
  delete fFinRdt; fFinRdt = NULL;
  delete fFinHdt; fFinHdt = NULL; 
  //  fFinHdt->ClearArrays(); // can not delete fFinHdt now
  //  if(fOnlineFlag = ONL_OFF && fRawEvent != 0) delete [] fRawEvent;  

  if(fDebug) cout << "TFndRun::CleanEvent Info: Event cleaned" << endl;
}
 
//_____________________________
Int_t TFndRun::CheckMsqlConnection(){
  // return the output of msqlConnect()

  if(fDebug) Info("CheckMsqlConnection", " Checking connection to msql: host \"%s\"", ExpandPathName(fDBHost).Data());

  Int_t ntry = 0;
  Int_t nmaxtry = 30;
  Int_t sd = -1;
  
  while(1){
    sd = msqlConnect((Char_t *)fDBHost.Data());
    if(sd != -1){
      gSystem->Sleep(50);
      msqlClose(sd);
      gSystem->Sleep(50);
      return sd;
    }
    if(ntry){
      Info("CheckMsqlConnection", "No connection to DB on \"%s\": retrying (%d).", fDBHost.Data(), ntry);
      Warning("CheckMsqlConnection", "msql connection not available: retrying...");
    }
    ntry++;
    if(ntry>=nmaxtry){
      Warning("CheckMsqlConnection", "msql connection Maximum number of attempts reached");
      return sd;
    }
    gSystem->ProcessEvents();
    gSystem->Sleep(1000);
  }
  
  if(fDebug) Info("CheckMsqlConnection", " Socket to msql opened with identifier %d on \"%s\"", sd, fDBHost.Data());
  msqlClose(sd);

  return sd;
}

//___________________________________________
Int_t TFndRun::ConnectToDB(){
  // return value:
  //              -1: DB internal error
  //              -2: Pointer to Database Interface not defined
  //              -3: Already connected
  //              -4: DB-connection not available
  //         (other): DB-connection socket descriptor
  //
  // TFndFeeMap is becoming deprecated!
  // support for mysql is coming soon...
  
  if(!fFeeMap){
    Error("ConnectToDB","Pointer to Database Interface not defined");
    return -2;
  }
  if(fFeeMap->IsConnected()){
    Error("ConnectToDB","Already connected to DB");
    return -3;
  }
  if (CheckMsqlConnection() < 0) {
    Error("InitNewRun", "No connection to database");
    return -4;
  }

  Info("ConnectToDB", "Connecting to database (DB-host: \"%s\")",fDBHost.Data());
  Int_t sd = fFeeMap->ConnectToHost(fDBHost);
  if(sd == -1) Warning("ConnectToDB","No connection to database (DB internal error)");
  return sd;
}

//___________________________________________
Int_t TFndRun::DisconnectFromDB(){
  // return value:
  //               0: ok (connection succesfully closed)
  //              -1: no poiter to DB Interface: doing nothing
  // 
  // TFndFeeMap is becoming deprecated!
  // support for mysql is coming soon...
  
  if(!fFeeMap){
    Warning("DisconnectFromDB","Pointer to Database Interface not found");
    return -1;
  }

  fFeeMap->DisconnectFromHost();
  return 0;
}

//___________________________________________
Int_t TFndRun::FetchDBinfo(Int_t source,Bool_t verbose){
  //
  // available values for "source" (see FROOT.h::EFndDBFetchSource):
  //    - K_DB_SOURCE_HOST (raw-event runtime is used to fetch information)
  //    - K_DB_SOURCE_FILE (previousley fetched info are grabbed from current HDT root-file)
  //
  // return value:
  //               0: ok
  //              -1: DB internal error
  //              -2: Pointer to Database Interface not defined
  //              -3: Current interface to DB not connected
  //
  // TFndFeeMap is becoming deprecated!
  // support for mysql is coming soon...

  
  //   if(source == (Int_t)(K_DB_SOURCE_FILE)){    
  //     fFeeMap = (TFndFeeMap*) fHdtRootFile->Get("TFndFeeMap");
  //     return 0;
  //   }
  //   if(source != (Int_t)(K_DB_SOURCE_HOST)){
  //     Error("FetchDBinfo","Wrong call (source not available)");
  //     TerminateFroot();
  //   } 
  // previous lines shall be replaced with a "switch" in case of more than two sources
  
  // still thinking about geting DB info from a previousely saved root-file
  // (in case of source==K_DB_SOURCE_FILE the complete path to the hdt-root-file shall be provided)

  if(!fFeeMap){
    Error("FetchDBinfo","Pointer to Database Interface not defined");
    return -2;
  }
  if(!fFeeMap->IsConnected()){
    Error("FetchDBinfo","Not connected to DB");
    return -3;
  }
  
  Info("FetchDBinfo","Fetching info from DB host");
  Int_t ierr = fFeeMap->FetchRunInfo(verbose);
  if(fDebug) Info("FetchDBinfo","ierr = %d",ierr);

  // --- if no database has been loaded yet...
  if(!fFeeMap){
    Error("FetchDBinfo","Why not connected yet?");
    TerminateFroot();
  }

  // --- debugging info
  //   fFeeMap->PrintTofCalibInfo();
  //   fFeeMap->PrintLmdCalibInfo();
  //   fFeeMap->PrintStbCalibInfo();
  //

  if(fDebug ==0) Info("FetchDBinfo","done");  
  return 0; // return value will take into acount the DB-connection status
  //--- new connection to mysql coming soon
}

//___________________________________________
Int_t TFndRun::CreateSocketToDAQ(E_Fnd_DaqRaw_Udp_Ports det_port){

  fUdpSd= socket(AF_INET, SOCK_DGRAM, 0);
  // reset (and set) the socket
  bzero((char*)&fLocSockAddr,sizeof(fLocSockAddr));
  fLocSockAddr.sin_family      = AF_INET;
  fLocSockAddr.sin_addr.s_addr = INADDR_ANY;  
  fLocSockAddr.sin_port        = 0; 
  
  Info("CreateSocketToDAQ","new socket created with socket descriptor %d; now binding...",fUdpSd);
  int bind_err = bind(fUdpSd, (struct sockaddr *) &fLocSockAddr, sizeof(fLocSockAddr)); 
  if(bind_err == -1) TerminateFroot(0,"TFndRun::CreateSocketToDAQ ---> Bind operation failed!");
  Info("CreateSocketToDAQ","...done (bind_err = %d)",bind_err);
  
  // The initialization of fShrSockAddr is required in order to send requests   //
  // The process, anyway, must be binded to fLocSockAddr: can not send/receive  //
  // data by using the binded structure!                                        //
  
  bzero((char*)&fShrSockAddr,sizeof(fShrSockAddr));
  fShrSockAddr.sin_family      = AF_INET;
  fShrSockAddr.sin_addr.s_addr = htonl(fGebIp);
  fShrSockAddr.sin_port        = htons(det_port); 
  fShrSockAddr_size    = sizeof(fShrSockAddr);;
  
  // set the current socket (through the descriptor) to receive events
  int sock_err = setsockopt(fUdpSd,SOL_SOCKET,SO_RCVBUF,&fSockLength,sizeof(fSockLength));
  if(sock_err==-1) TerminateFroot(0,"TFndRun::CreateSocketToDAQ ---> setsockopt failed failed!");
  return 0;

}

//___________________________________________
Int_t TFndRun::CheckSocketToDAQ(){
  // set according to a minimum rate of 1ev/3s

  Int_t check_result=0;
  Int_t nn = 0;
  while(nn < 50){ // was 10
    nn++;
    //    cout << "check socket " << nn << endl;
    ioctl(fUdpSd,FIONREAD,(Int_t *)&check_result);
    if(check_result != 0) break;
    usleep(3000); // according to maximum rate required (was 5000)
    // slow down depending on answer time (DAQ rate)
    if(nn >  2) usleep(10000);
    if(nn >  3) usleep(40000);
    if(nn >  5) usleep(500000);
    if(nn >  7) usleep(500000);
    if(nn >  9) usleep(100000);
    //     if(nn > 11) usleep(100000);
    //     if(nn > 13) usleep(100000);
    //     if(nn > 15) usleep(100000);
    //     if(nn > 17) usleep(100000);
    //     if(nn > 19) usleep(500000);
  }
  return check_result;
}

//___________________________________________
Int_t TFndRun::ShutdownSocketToDAQ(){
  return shutdown(fUdpSd,SHUT_RDWR);
}

//___________________________________________
UInt_t *TFndRun::GetNextRawEventFromSocket(int &exit_val){
  // get the next raw-event (from socket)
  // send the request
  // NOTE:
  //   A loop of requests is required, unless you are sure
  //   that the server is already running and witing for client requests
  //    "ioctl" is used to know if the request has been received by the server
  //
  // tested with simulated DAQ rate in the range [0.3 - 200] ev/s
  //
  // exit_val value: 
  //                0: ok
  //               -2: must re-create socket
  
  bzero(fRawEvent,sizeof(fRawEvent));
  //   char request_buf[100];
  //   sprintf(request_buf,"send me an event");

  Int_t request_buf=1;
  
  Int_t n_max_requests = 50; // after 50 requests recreate socket (was 10)
  
  int n_trials = 0;
  while(1){
    n_trials++; if(n_trials> n_max_requests){
      exit_val = -2;
      return 0;
    }
    request_counter++;
    //Info("GetNextRawEventFromSocket","sending request to the server (%d)",request_counter);
    //int send_err = sendto(fUdpSd,(char*)request_buf ,sizeof(request_buf) ,0 ,(struct sockaddr *) &fShrSockAddr,fShrSockAddr_size);
    int send_err = sendto(fUdpSd,(char*)&request_buf ,sizeof(Int_t) ,0 ,(struct sockaddr *) &fShrSockAddr,fShrSockAddr_size);    
    if(send_err==-1){
      Error("GetNextRawEventFromSocket","send-request operation failed!");
      sleep(1);
      continue;
    }

    int check_result=CheckSocketToDAQ(); // wait for answer
    // cout << "check_result: " << check_result << endl;
    if(check_result) break;
    else Info("GetNextRawEventFromSocket","...server not ready: trying again");
  }
  // the data fRawEvent is sent from the server to the "sockaddr_in" who sent the request (so it is used to receive)
  Int_t nread = recvfrom(fUdpSd ,(char*)fRawEvent ,sizeof(fRawEvent) ,0 ,(struct sockaddr*)&fShrSockAddr , (socklen_t *) &fShrSockAddr_size);

  if(fDebug > 0) printf("UDP fRawEvent received from server: nread = %d; event = \"%x\".\n",nread,fRawEvent);

  if(nread == -1){
    Error("GetNextRawEventFromSocket","nread = -1");
    exit_val = -2;
    return 0;
  }
  else if(nread == 0){
    Error("GetNextRawEventFromSocket","connection closed by GEB");
    exit_val = -2;
    return 0;
  }

  Int_t u_length = nread / sizeof(fRawEvent[0]);
  if( u_length >= sizeof(fRawEvent) ){
    Warning("GetNextRawEventFromSocket","received buffer size greater than local buf-size");
    exit_val = -2;
    return 0;
  }
  if( u_length != fRawEvent[0] ){
    Warning("GetNextRawEventFromSocket","received buffer size different from event size");    
    exit_val = -2;
    return 0;
  }

  if(fDebug > 0) if(u_length == fRawEvent[0]) Info("GetNextRawEventFromSocket","received event OK");
  // --- CHECKS completed

  if(fDebug > 1){
    for(unsigned int j=0; j<5; j++){
      if(fRawEvent[j] != 0) cout << "fRawEvent[" << j << "] = " << fRawEvent[j] << endl;
    }
  }
  else if(fDebug > 2){
    unsigned int len_test = fRawEvent[0];
    for(unsigned int j=0; j<len_test; j++){
      if(fRawEvent[j] != 0) cout << "fRawEvent[" << j << "] = " << fRawEvent[j] << endl;
    }
  }
 
  CheckRawSwapping();

  exit_val = 0;
  return fRawEvent;  
}

//___________________________________________
UInt_t *TFndRun::GetNextRawEventFromFile(int &exit_val){
  // get the next raw-event (from file)

  UInt_t evlen;
  if(fDebug > 1) Info("GetNextRawEventFromFile", "Get event from disk");
  if(fread(&evlen, sizeof(UInt_t), 1 , fRawFile)!=1) {
    Info("GetNextRawEventFromFile", "End of Run reached");
    exit_val = 2;
    return 0; 
  }
  bzero(fRawEvent,sizeof(fRawEvent));
  fRawEvent[0] = (UInt_t) evlen;
  Int_t read_length = 1 + fread(fRawEvent+1, sizeof(UInt_t), evlen-1, fRawFile);
  if(read_length != evlen) Error("GetNextRawEventFromFile","wrong length from freed"); 

  CheckRawSwapping();
  return fRawEvent;  
}

//___________________________________________
UInt_t *TFndRun::GetNextRawEvent(Int_t &exit_value){
  // This method can be used by any application.
  //
  // Get the pointer to the next raw event and
  // store it into the relative data member
  //
  // exit_value:
  //             0: good event: go on
  //            -2: No answer received from DAQ (online mode only)
  //            -1: (not used here)
  //             1: requested number of events reached
  //             2: end of run reached

  exit_value = 0; 

  if(fNumOfProcessedEvents >= fMaxNofEvents) {
    Info("GetNextRawEvent", "Requested number of events reached: process completed");
    exit_value = 1;
    return 0; 
  }
  if(fDebug) Info("GetNextRawEvent", "fOnlineFlag: %d", fOnlineFlag);
  
  if(fOnlineFlag == (Int_t)(ONL_OFF)){
    GetNextRawEventFromFile(exit_value);
  }
  else{ // online mode    
    GetNextRawEventFromSocket(exit_value);
    if(exit_value == -2){
      RecreateSocketToDAQ();
      return 0;
    }
  }
  
  //  if(GetEvNum_Raw() % 100 ==0) Printf("GetNextRawEvent ---> Event: %u; exit_val = %d",GetEvNum_Raw(),exit_value);

  fNumOfProcessedEvents++;
  return fRawEvent;

}

//___________________________________________
void TFndRun::CheckRawSwapping(){
  // bytes swapping is applied to current raw event if needed

  UInt_t evlen = fRawEvent[0];
  //evlen = fRawEvent[0];
  Int_t unswpd_len = 0;
  Int_t swpd_len = 0;
  Int_t swap = 0;
  unswpd_len = evlen;
  swpd_len = host2net(evlen);
  swap = 0;
  //  Printf("Checking swap  ---> unswapped length: %d", unswpd_len);
  //  Printf("Checking swap  ---> swapped length: %d", swpd_len);
  if(unswpd_len <= 0) {
    evlen = swpd_len;
    swap = 1;
  }
  else if(swpd_len <= 0) {
    evlen = unswpd_len;
    swap = 0;
  }
  else {
    if(swpd_len < unswpd_len) {
      evlen = swpd_len;
      swap = 1; 
    }
    else {
      evlen = unswpd_len;
      swap = 0;
    }
  }
  //  Printf("Checking swap  ---> event length: %u; swap flag: %d", evlen,swap);
  if(swap == 1) for (UInt_t j=1; j<evlen;  j++) fRawEvent[j] = host2net(fRawEvent[j]);
}

//___________________________________________
Bool_t TFndRun::IsNewRun(){
  
  if( fCurRunType.IsNull() || 
      fCurRunType.CompareTo(DecodeRunType(fRawEvent[3]) )!=0 || 
      fRawEvent[4] != fCurRunNum)
    {
      fIsNewRun = kTRUE;
      if(fDebug) Info("IsNewRun"," New run set to true (fRunType: \"%s\"; raw: \"%s\")",fCurRunType.Data(),DecodeRunType(fRawEvent[3]).Data());
      if(fDebug > 1){
        Info("IsNewRun","fCurRunType.CompareTo(DecodeRunType(fRawEvent[3]) ): %d",fCurRunType.CompareTo(DecodeRunType(fRawEvent[3]) ) );
        Info("IsNewRun","fRawEvent[4] = %u ; fCurRunNum = %u", fRawEvent[4],fCurRunNum );
      }
    }
  return fIsNewRun;
}

//___________________________________________
Int_t TFndRun::ReadRawEvent(Bool_t using_db){
  // read and unpack current raw event filling the HDT structure
  // Use this methoid after "GetNextRawEvent" only!
  // returned values:
  //                 -1: DB-error
  //                  0: good event: go on (also for first event of a new run)
  //
  // NOTE: if you call this method you will fill HDT structure,
  //       since the decoding is useless...
  
  if(fDebug) Info("ReadRawEvent", "entering method: online flag = %d",fOnlineFlag);
  
  if(fOnlineFlag == ONL_ALL) IsNewRun();
  
  if(fRawEvent[13] != 0) Info("ReadRawEvent", "event 0 at event: %d, location: %u", fRawEvent[2], fRawEvent[13]); // next cicle if "Event 0"
  
  if(fDebug && (fOnlineFlag == ONL_ALL || fOnlineFlag == ONL_OFF)) Info("ReadRawEvent", "entering method: Run  %u; Event %u", fRawEvent[4],fRawEvent[2]);
  
  if(fIsNewRun == kTRUE) { // new run (first event) operations
    Info("ReadRawEvent",
         "Performing new run operations (run type: \"%s\"; run number = %u; event number = %u",
         DecodeRunType(fRawEvent[3]).Data(),
         fRawEvent[4],
         fRawEvent[2]);
    delete fGenInfo;
    fGenInfo = new TFndGenInfo(fRawEvent);
    fRunTime = fRawEvent[5];
    
    // DB info must be fetched from the official database if reading raw-data
    if(using_db){
      Info("ReadRawEvent","Fetching information from DB");
      if(!fFeeMap->IsConnected()){
        if(ConnectToDB() < 0) return -1;  
      }
      if(FetchDBinfo(K_DB_SOURCE_HOST) != 0) TerminateFroot();
      DisconnectFromDB();
      fFinRdt->Reload();  // very important!
    }  
    // ---
    fIsNewRun = kFALSE;
    fCurRunType = DecodeRunType(fRawEvent[3]);
    fCurRunNum = fRawEvent[4];
    Info("ReadRawEvent","New run operations succesfully performed for run %u",fCurRunNum);
    if(fDebug) Info("ReadRawEvent","New run set to false");
    if(fOnlineFlag == ONL_ALL){
      Info("ReadRawEvent","\n\n\n");
      Info("ReadRawEvent"," -----------------------------------");
      Info("ReadRawEvent","   ---- NEW RUN started (%s %u)",fCurRunType.Data(),fCurRunNum);
      Info("ReadRawEvent"," -----------------------------------\n\n\n");
      // Histograms reset can be added if needed
      fFinHdt->Reset(); // created once and then recycled
      fFinHdt->SetEventProperties(fRawEvent[4],fRawEvent[2]);     
      return 0;
    }
  }
  
  if(!fFinRdt) TerminateFroot(0,"TFndRun::ReadRawEvent ---> fFinRdt not present!");
  
  fFinHdt->Reset(); // created once and then recycled
  fFinHdt->SetEventProperties(fRawEvent[4],fRawEvent[2]);

  if(fDebug) Info("ReadRawEvent", "mapping RDT to HDT");
  if(!using_db) return 0;
  
  if(using_db){  
    //    Printf("fFinHdt in TFndRun: 0x%x",fFinHdt);
    fFinRdt->RdtToHdt(fRawEvent,0);
    fFinHdt->EvalHits();
    FillMonitors();
  }
  
  if(fDebug) Info("ReadRawEvent", "exiting method");
  return 0;
}

//___________________________________________
Int_t TFndRun::GetNextEvent(Bool_t fill_hdt){
  // This method is used by the online monitor only
  //
  // return values:
  //                 -2: No answer received from DAQ (online mode only)
  //                 -1: DB-error
  //                  0: good event: go on
  //                  1: requested number of events reached
  //                  2: end of run reached
  
  if(fDebug) Info("GetNextEvent", "entering method");
  Int_t istop = 0;

  if(fDebug) cerr << "getting new event; last processed event: " << fNumOfProcessedEvents << endl;
  // // remember to call ClearEvent() when you are using directly "GetNextRawEvent"
  // --------------------------------------------------------
  if(fRawEvent && fRawEvent[0]!=0){
    Warning("GetNextEvent","You forgot to call TFndRun::ClearEvent! forcing Clear operation (ev: %u).",GetEvNum_Raw());
    ClearEvent();
  }
  GetNextRawEvent(istop);
  if(istop) return istop;
  // --------------------------------------------------  
  if(fDebug) cerr << "event " << GetEvNum_Raw() << " got" << " (fNumOfProcessedEvents: " << fNumOfProcessedEvents << endl;

  if(fill_hdt) istop = ReadRawEvent();

  if(fDebug) cerr << "event " << fNumOfProcessedEvents  << " completed" << endl;
  return istop;
}

//_____________________________
Int_t TFndRun::ReconstructEvent(){
  // Custom reconstruction
  // of the current raw event (fRawEvent)

  Info("ReconstructEvent", "Global Event address        : %p", fRawEvent);
  Info("ReconstructEvent", "Global Event Length         : %u", fRawEvent[0]);
  Info("ReconstructEvent", "Raw event number (hardware) : %u", fRawEvent[1]);
  Info("ReconstructEvent", "Raw event number (software) : %u", fRawEvent[2]);

  return 0;
}

//___________________________________________
void TFndRun::StartMonitors(){
  // Start all TFnd*Mon in Producer mode ---- check ---
  // please do not change the order!
  
  Bool_t at_least_one = kFALSE;
  for(Int_t i= (Int_t)D_GTS; i<= (Int_t)D_STB; i++) at_least_one = at_least_one || fMustFillMonitor[i];
  if(!at_least_one){
    Info("StartMonitors","No monitor will start (histograms)");
    return;
  }
  
  if( !fRunFilename.IsNull() ){
    fMonHisFilename=fRunFilename;
    TString def_pth= ExpandPathName("$FND_MON_HISTOS");
    if( !def_pth.IsNull() && gSystem->AccessPathName(def_pth)==0 ) fMonHisFilename.Form("%s/%s",def_pth.Data(),fRunFilename.Data());
  }
  
  if( fMonHisFilename.IsNull() )  Info("StartMonitors", "Start Monitors in online mode");
  else Info("StartMonitors", "Start Monitors with fMonHisFilename: %s", fMonHisFilename.Data());

  if(fMustFillMonitor[(Int_t)D_GTS] ){
    Info("StartMonitors","Starting GTS");
    fGtsMon = new TFndGtsMon(fMonHisFilename.Data());
  }

  if(fMustFillMonitor[(Int_t)D_TOF] ){
    Info("StartMonitors","Starting TOF");
    StartTofMonitor();
  }

  if(fMustFillMonitor[(Int_t)D_SIL] ){
    Info("StartMonitors","Starting ISIM");
    StartIsmMonitor();
    
    Info("StartMonitors","Starting OSIM");
    StartOsmMonitor();
  }
  
  if(fMustFillMonitor[(Int_t)D_LMD] ){
    Info("StartMonitors","Starting LMD");
    StartLmdMonitor();
  }
  
  if(fMustFillMonitor[(Int_t)D_STB] ){  
    Info("StartMonitors","Starting STB");
    StartStbMonitor();
  }
  
  Info("StartMonitors","all monitors started ");
  return;
}
//___________________________________________
void TFndRun::StartGtsMonitor(){
  // Start TFndGtsMon in Producer mode

  fGtsMon = new TFndGtsMon(fMonHisFilename.Data());
  return;
}

//___________________________________________
void TFndRun::StartTofMonitor(Int_t adc_bins,Float_t adc_min,Float_t adc_max,Int_t tdc_bins,Float_t tdc_min,Float_t tdc_max){
  // Start TFndTofMon in Producer mode
  if(!fRunConfiguration){
    Warning("StartTofMonitor","Run Configuration file not loaded: can not start monitor");
    return;
  }
  if(adc_bins > K_MAX_BINS_ADC || adc_bins <= 0) fRunConfiguration->GetAdcRange(D_TOF,adc_bins,adc_min,adc_max);
  if(tdc_bins > K_MAX_BINS_TDC || tdc_bins <= 0) fRunConfiguration->GetTdcRange(D_TOF,tdc_bins,tdc_min,tdc_max);

  fTofMon = new TFndTofMon(fMonHisFilename.Data(),adc_bins,adc_min,adc_max,tdc_bins,tdc_min,tdc_max);
  
  return;
    
}

//___________________________________________
void TFndRun::StartIsmMonitor(){

  fIsmMon = new TFndSilMon(fMonHisFilename.Data(),1);
  return;
}

//___________________________________________
void TFndRun::StartOsmMonitor(){

  fOsmMon = new TFndSilMon(fMonHisFilename.Data(),2);
  return;
}

//___________________________________________
void TFndRun::StartLmdMonitor(Int_t adc_bins,Float_t adc_min,Float_t adc_max,Int_t tdc_bins,Float_t tdc_min,Float_t tdc_max){
  // Start TFndLmdMon in Producer mode
  if(!fRunConfiguration){
    Warning("StartLmdMonitor","Run Configuration file not loaded: can not start monitor");
    return;
  }
  if(adc_bins > K_MAX_BINS_ADC || adc_bins <= 0) fRunConfiguration->GetAdcRange(D_LMD,adc_bins,adc_min,adc_max);
  if(tdc_bins > K_MAX_BINS_TDC || tdc_bins <= 0) fRunConfiguration->GetTdcRange(D_LMD,tdc_bins,tdc_min,tdc_max);
  fLmdMon = new TFndLmdMon(fMonHisFilename.Data(),adc_bins,adc_min,adc_max,tdc_bins,tdc_min,tdc_max);
  return;
}

//___________________________________________
void TFndRun::StartStbMonitor(Int_t tdc_bins,Float_t tdc_min,Float_t tdc_max){
  // Start TFndStbMon in Producer mode
  if(!fRunConfiguration){
    Warning("StartStbMonitor","Run Configuration file not loaded: can not start monitor");
    return;
  }
  if(tdc_bins > K_MAX_BINS_TDC || tdc_bins <= 0) fRunConfiguration->GetTdcRange(D_STB,tdc_bins,tdc_min,tdc_max);
  
  fStbMon = new TFndStbMon(fMonHisFilename.Data(),tdc_bins,tdc_min,tdc_max);
  return;
}

//___________________________________________
void TFndRun::StartGtsMonitor(TString *str){
  // Start TFndGtsMon in read mode:
  // from a ".root" file (previously produced)

  if(!fGtsMon) {
    if(fOnlineFlag == ONL_OFF) {
      Info("StartGtsMonitor", "Start Gts monitor in offline mode.");
      fGtsMon = new TFndGtsMon(str);
    }
    else {
      Info("StartGtsMonitor", "Start Gts monitor in online mode.");
      fGtsMon = new TFndGtsMon();    
    }
  }
  return;
}

//___________________________________________
void TFndRun::StartTofMonitor(TString *str){
  // Start TFndTofMon in read mode:
  // from a ".root" file (previously produced)

  if(!fTofMon) {
    if(fOnlineFlag == ONL_OFF) {
      Info("StartTofMonitor", "Start Tof monitor in offline mode");
      fTofMon = new TFndTofMon(str);
    } 
    else {
      Info("StartTofMonitor", "Start Tof monitor in online mode");
      fTofMon = new TFndTofMon();    
    }
  }
  return;
}

//___________________________________________
void TFndRun::StartIsmMonitor(TString *str){
  // Start TFndIsmMon in read mode:
  // from a ".root" file (previously produced)

  if(!fIsmMon) {
    if(fOnlineFlag == ONL_OFF){
      Info("StartIsmMonitor", "Start Ism monitor in offline mode");
      fIsmMon = new TFndSilMon(str->Data(),1);
    }
    else {
      Info("StartIsmMonitor", "Start Ism monitor in online mode");
      fIsmMon = new TFndSilMon();
    }
  }
  return;
}

//___________________________________________
void TFndRun::StartOsmMonitor(TString *str){
  // Start TFndOsmMon in read mode:
  // from a ".root" file (previously produced)
  
  if(!fOsmMon) {
    if(fOnlineFlag == ONL_OFF){
      Info("StartOsmMonitor", "Start Osm monitor in offline mode");
      fOsmMon = new TFndSilMon(str->Data(),2);
    }
    else {
      Info("StartOsmMonitor", "Start Osm monitor in online mode");
      fOsmMon = new TFndSilMon();
    }
  }
  return;
}

//___________________________________________
void TFndRun::StartLmdMonitor(TString *str){
  // Start TFndLmdMon in read mode:
  // from a ".root" file (previously produced)

  if(!fLmdMon) {
    if(fOnlineFlag == ONL_OFF) {
      Info("StartLmdMonitor", "Start Lmd monitor in offline mode");
      fLmdMon = new TFndLmdMon(str);
    } 
    else {
      Info("StartLmdMonitor", "Start Lmd monitor in online mode");
      fLmdMon = new TFndLmdMon();
    }
  }
  return;
}

//___________________________________________
void TFndRun::StartStbMonitor(TString *str){
  // Start TFndStbMon in read mode:
  // from a ".root" file (previously produced)

  if(!fStbMon) {
    if(fOnlineFlag == ONL_OFF) {
      Info("StartStbMonitor", "Start Stb monitor in offline mode");
      fStbMon = new TFndStbMon(str);
    } 
    else {
      Info("StartStbMonitor", "Start Stb monitor in online mode");
      fStbMon = new TFndStbMon();
    }
  }
  return;
}

//___________________________________________
Int_t TFndRun::StartMonFrame(Int_t det,TString RootFileName,TString RootFileName2){
  // Start the monitor-frame (consumer-GUI) for the selected detector
  //    (see FROOT:: EFndMonDetectors)
  //
  // If RootFileName and RootFileName_2 is not passed, then online-mode is selected
  //   (RootFileName_2 is used for SIL only)
  // 
  // return value:
  //               0 : ok
  //               1 : deleting old one
  //              -1 : detector selection error

  Int_t ret_val = 0;

  if(GetMonFrame(det)){
    DeleteMonFrame(det);
    ret_val = 1;
  }

  switch(det){
  case D_GTS:
    fGtsMonFrame = new TFndGtsMonFrame(RootFileName);
    fGtsMonFrame->Open();
    break; 
  case D_TOF: 
    fTofMonFrame = new TFndTofMonFrame(RootFileName);
    fTofMonFrame->Open();
    break; 
  case D_SIL: 
    fSilMonFrame = new TFndSilMonFrame(RootFileName,RootFileName2);
    fSilMonFrame->Open();
    break; 
  case D_LMD:
    fLmdMonFrame = new TFndLmdMonFrame(RootFileName);
    fLmdMonFrame->Open();
    break; 
  case D_STB:
    fStbMonFrame = new TFndStbMonFrame(RootFileName);
    fStbMonFrame->Open();
    break; 
  default:
    Error("StartMonFrame","det \"%d\" not accepted",det);
    return -1;
  }
  return ret_val;
}

//___________________________________________
TFndMonFrame *TFndRun::GetMonFrame(Int_t det){
  // Get current monitor-frame (consumer-GUI) for the selected detector (det)
  //
  // Remember to use casting to the needed class:
  //    (TFndGtsMonFrame *)fnrun->GetMonFrame((Int_t)(D_GTS))
  //    (TFndTofMonFrame *)fnrun->GetMonFrame((Int_t)(D_TOF))
  //    (TFndSilMonFrame *)fnrun->GetMonFrame((Int_t)(D_SIL))
  //    (TFndLmdMonFrame *)fnrun->GetMonFrame((Int_t)(D_LMD))
  //    (TFndStbMonFrame *)fnrun->GetMonFrame((Int_t)(D_STB))

  switch(det){
  case D_GTS: return (TFndMonFrame *) fGtsMonFrame; 
  case D_TOF: return (TFndMonFrame *) fTofMonFrame; 
  case D_SIL: return (TFndMonFrame *) fSilMonFrame; 
  case D_LMD: return (TFndMonFrame *) fLmdMonFrame; 
  case D_STB: return (TFndMonFrame *) fStbMonFrame; 
  default:
    Error("StartMonFrame","det \"%d\" not accepted",det);
    return 0;
  }
  return 0; // should never reach this line!
}

//___________________________________________
Int_t TFndRun::DeleteMonFrame(Int_t det){
  // Delete current monitor-frame (consumer-GUI) for the selected detector
  //    (see FROOT:: EFndMonDetectors)
  // 
  // return value:
  //               0 : ok
  //              -1 : detector selection error
  
  switch(det){
  case D_GTS: delete fGtsMonFrame; fGtsMonFrame = 0;  break; 
  case D_TOF: delete fTofMonFrame; fTofMonFrame = 0;  break; 
  case D_SIL: delete fSilMonFrame; fSilMonFrame = 0;  break; 
  case D_LMD: delete fLmdMonFrame; fLmdMonFrame = 0;  break; 
  case D_STB: delete fStbMonFrame; fStbMonFrame = 0;  break; 
  default:
    Error("StartMonFrame","det \"%d\" not accepted",det);
    return -1;
  }
  return 0;
}

//___________________________________________
void TFndRun::FillMonitors(){
  // Fill producer histograms

  if(fDebug > 0) Info("FillMonitors", "entering method");
  if(fGtsMon) fGtsMon->Fill();
  if(fTofMon) fTofMon->Fill();
  if(fIsmMon) fIsmMon->Fill();
  if(fOsmMon) fOsmMon->Fill();
  if(fLmdMon) fLmdMon->Fill();
  if(fStbMon) fStbMon->Fill();
  if(fDebug > 0) Info("FillMonitors", "exiting method");
  return;
}

//___________________________________________
void TFndRun::WriteMonitors(Bool_t close){
  // Write producer histograms to the relative root-files
  // (see "TFnd*Mon" classes)
  
  Info("WriteMonitors", "Writing Histograms To file (close: %d)",close);
  if(fGtsMon) close ? fGtsMon->WriteToFile() : fGtsMon->Update();
  //  cout << "DEBUG 1" << endl;
  if(fTofMon) close ? fTofMon->WriteToFile() : fTofMon->Update();
  //  cout << "DEBUG 2" << endl;
  if(fIsmMon) close ? fIsmMon->WriteToFile() : fIsmMon->Update();
  //  cout << "DEBUG 3" << endl;
  if(fOsmMon) close ? fOsmMon->WriteToFile() : fOsmMon->Update();
  //  cout << "DEBUG 4" << endl;
  if(fLmdMon) close ? fLmdMon->WriteToFile() : fLmdMon->Update();
  //  cout << "DEBUG 5" << endl;
  if(fStbMon) close ? fStbMon->WriteToFile() : fStbMon->Update();
  Info("WriteMonitors", "done");
  return;
}

//_______________________________________________________________________
void TFndRun::ReadConfigFile(TString ConfFileName){
  // calling this method will change the value of fDebug.

  TString ConfFuncName = "RunConfig()";
  
  if(gSystem->AccessPathName(ConfFileName)){
    Warning("ReadConfigFile", "file \"%s\" not found.", ConfFileName.Data());
    Warning("ReadConfigFile", "Configuration file \"%s\" not found in current directory: using defaults.", ConfFileName.Data());
    ConfFileName = FROOT::ExpandPathName("$FROOTSYS/mcr_called/RunConfig.C");
    Info("ReadConfigFile","The default configuration file is \"%s\"",(Char_t *)ConfFileName.Data());
  }
  if(gSystem->AccessPathName(ConfFileName)){
    Error("ReadConfigFile","Default configuration file \"%s\" not found! exiting program.",(Char_t *)ConfFileName.Data());
    TerminateFroot();
  }
  
  if(fDebug > 1) Info("ReadConfigFile", "Loading Macro %s", ConfFileName.Data());
  gROOT->LoadMacro(ConfFileName);
  if(fDebug > 1) Info("ReadConfigFile", "Loading configuration method \"%s\"", ConfFileName.Data());
  Info("ReadConfigFile", " Loading \"%s\"", (Char_t *) (ConfFileName.Data()));
  printf("TFndRun::ReadConfigFile Info:  Loading \"%s\"\n", (Char_t *) (ConfFileName.Data()));
  gInterpreter->ProcessLine(ConfFuncName);

  fDebug = fRunConfiguration->Debug();
  fDebugRawEv = fRunConfiguration->DebugRaw();

  for(Int_t i= (Int_t)D_GTS; i<= (Int_t)D_STB; i++) fMustFillMonitor[i] = fRunConfiguration->GetMustFillMonitor(i);

  //  cout << " ====================> " << fRunConfiguration->Debug() << " ; " << fDebug << endl;
  return;
}
//_______________________________________________________________________
Long_t TFndRun::OpenRawFile(TString fdir, TString fnam,Bool_t check_only){
  // Open raw file (or gzipped raw file)
  // and set the fRawFile pointer
  // return value: file size (-1 in case of problems)
  // if the "check_only" argument is true, then the file will not be open

  Bool_t is_zipped = kFALSE;  

  TString gzip  = TString("gzip -cd ");
  TString sufx  = TString(".gz");
  TString fname = FROOT::ExpandPathName(fdir);
  fname+="/";
  fname+=fnam;
  fname+=".raw";
  // -- file existence check
  //   if(!CheckFileExistence(fname)){
  //     if(fDebug > 0) Warning("OpenRawFile", "File not found");
  //     return -1;
  //   }
  // file existence check completed ---
  
  if(!check_only){ 
    // performed by default 
    gzip+=fname.Data();
    gzip+=sufx.Data();
    if(fDebug > 0) cout << "TFndRun::OpenRawFile Info: Opening " << fname.Data() << endl;
    fRawFile = fopen(fname.Data(),"rb");
    if (fRawFile==NULL) {
      if(fDebug) cout << "TFndRun::OpenRawFile Info: Opening zipped file" << endl;
      is_zipped = kTRUE;
      fRawFile = popen(gzip.Data(),"r");
      if (fRawFile==NULL) {   
        printf("TFndRun::OpenRawFile Warning: file %s does not exist\n", fname.Data());
        return -1;
      }
    }
    //
    TString msg_sf = is_zipped ? ".gz" : "";
      // fname+=sufx.Data();
    if(fDebug > 1 && !check_only) printf("TFndRun::OpenRawFile Info: file %s%s opened.\n", fname.Data(), msg_sf.Data());
  }
  

  // --- last check: file size (File stats check)
  // Get info about a file: id, size, flags, modification time.
  is_zipped = kFALSE;
  Long_t id = 0;
  Long_t size = 0;
  Long_t flags = 0;
  Long_t modtime = 0;
  Int_t InfoRes = -1; // zero means "success"
  
  InfoRes = gSystem->GetPathInfo(fname.Data(),&id,&size,&flags,&modtime);
  if(InfoRes){
    is_zipped = kTRUE;
    fname+=sufx;
    InfoRes = gSystem->GetPathInfo(fname.Data(),&id,&size,&flags,&modtime);
  }
  //
  if(!InfoRes){
    if(fDebug > 1)
      printf("TFndRun::OpenRawFile Info: file size: %d (zipped: %d)\n", size, is_zipped);
    if(fDebug > 2)
      printf("TFndRun::OpenRawFile Info: name: \"%s\"; id: %ld; size: %ld; flags: %ld; mod time\n", 
             fname.Data(), id, size, flags, modtime);
    
    return size;
  }
  else{
    printf("TFndRun::OpenRawFile Info: can not stat file \"%s\"\n",fname.Data());
    return -1;
  }
}


//_______________________________________________________________________
void TFndRun::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);

}

//_______________________________________________________________________
void TFndRun::CloseLogFile(){

  if(!fCurLogFile) return;
  fCurLogFile->close();
  delete fCurLogFile;
  fCurLogFile = 0;
}

//_______________________________________________________________________
void TFndRun::WriteLogFile(const TString &line){

  if(!fCurLogFile){
    
    return;
  }
  *fCurLogFile << line.Data() << endl;
}
   

---