STEER/FROOT.h

// @(#)fROOT/STEER:$Name:  $:$Id: FROOT.h,v 1.74 2007/10/16 12:03:43 Diego_Faso Exp $
// Author: H. So, Diego Faso <mailto:faso@to.infn.it>, 2006/05/19

#ifndef FROOT_FROOT
#define FROOT_FROOT

// Declarations

#include <TString.h>
#include <TApplication.h>
#include <TThread.h>
#include <TMath.h>
#include <Riostream.h>

// uncomment the following line in order to enable
//  the automatic sub-directory handling of output files
#define _FND_OUTPUTS_USE_SUBDIR

// enable following symbol for TFndEvd
// to look for tracks into pre-analysis trees
#define FNDEVD_USE_PREAN

//#define _FND_ONL_USE_MAP_FILES_ // no support for this option
#define _FND_ONL_USE_SHARED_FILES_

//#define _FND_USE_TOUCH_MAP_FILES // no support for this option
//#define _FND_USE_HANDLE_CONSUMER_ACTIONS // testing purposes only

//                                                                                 //
//              RECONSTRUCTION METHOD CUSTOMIZATION (as "sel" in cmz)              //
//                                                                                 //
//                                                                                 //
// Just comment/uncomment following lines according to the chosen                  //
// reconstruction method.                                                          //
//                                                                                 //
// NOTE:                                                                           //
//      You must have compiled the (linked) fidarc-libraries                       //
//      according to the same customization you are setting here                   //
//                                                                                 //

#define FIDA_USE_SHORT // if defined ===> using short tracks (default from v_603 on)
//#define FIDA_USE_KALMAN // if defined ===> using Kalman filter (default from v_603 on)

//

namespace FROOT {

#if defined _FND_ONL_USE_MAP_FILES_ && defined _FND_ONL_USE_SHARED_FILES_
# error "FROOT.h error: <_FND_ONL_USE_[...]_FILES_> is unbiguous!"
#elif !defined _FND_ONL_USE_MAP_FILES_ && !defined _FND_ONL_USE_SHARED_FILES_
# error "TFndGtsMon error: <_FND_ONL_USE_[...]_FILES_> undefined!"
#endif
  
  // comment the required line to disable the
  //   raw-event decoding for a specific detector
  //   (see TFndRdt::RdtToHdt)
  // 
  // following selections shall be changed by expert users only:
#define _FND_ENABLE_RAW_GTS
#define _FND_ENABLE_RAW_TOF
#define _FND_ENABLE_RAW_ISIM
#define _FND_ENABLE_RAW_OSIM
#define _FND_ENABLE_RAW_LMD
#define _FND_ENABLE_RAW_STB

  TString GetFrootVersion();
  Float_t GetFrootVersionID();

  static const UInt_t Fee_Lmd_NewTdcsTime = 1045868400;  // Sat Feb, 2003; 22 00:00:00
  static const UInt_t DTak_2006_SftwStartTime = 1145138400; // Sun Apr 16, 2006;  00:00:00 (Start time for TOFDB2 database)
  static const UInt_t Fee_2006_NewSilDB_StartTime  = 1154383200; // Tue Aug 01,2006; 00:00:00 (Start time for TOFDB2 database)
  static const UInt_t DTak_2006_SftwStopTime = 1183500000; //  Wed July 4, 2007; 00:00:00
  // GENERAL description
  enum E_Fnd_Layer {
    E_FIN_INNER_LAYER = 1,
    E_FIN_OUTER_LAYER = 2
  }; // used for LMD/TOF/SIL (stb have their 6 layers [num:1-6])
  
  enum E_Fnd_Side {
    E_FIN_SIDE_E = 0,
    E_FIN_SIDE_P = 1
  };
  enum E_Fnd_Sil_Side {
    E_FIN_SIL_SIDE_PH = 0,
    E_FIN_SIL_SIDE_ZA = 1,
    E_FIN_SIL_SIDE_ZB = 2
  };
    
  TString SilSide_Name(Int_t id);

  static const Int_t K_N_TOFINO_SLABS =  12;
  static const Int_t K_N_TOFONE_SLABS =  72;

  static const Int_t K_N_LMD_LAYERS = 2;      // Number of LMD layers
  static const Int_t K_N_LMD_CHAMS_PER_LAYER = 8;        // Number of Drift Chambers / Layer
  static const Int_t K_N_LMD_INNER_WIRES = 12;      // Number of wires / chamber in the ineer layer
  static const Int_t K_N_LMD_OUTER_WIRES = 22;      // Number of wires / chamber in the outer layer
  static const Int_t K_N_LMD_TOT_CHAMS = 16;  // Total number of chambers 

  inline Int_t GetDataTakingFromTime(UInt_t runtime){
    if(runtime < DTak_2006_SftwStartTime) return 1;
    else if(runtime <= DTak_2006_SftwStopTime) return 2;
    else return 0;
  }


  inline Double_t TofinoZetaFromCharge(Int_t dtak,const Double_t &adcE,const Double_t &adcP)
    {
      if(! adcE || !adcP){
        cerr << "Error in FROOT::TofinoZetaFromCharge: NULL value received." << endl;
        return -1;
      }
      Double_t chdiv = adcE / adcP;
      Double_t logch = 0;
      switch(dtak){
      case 1:
        logch = TMath::Log(chdiv);
        //      cout << "RETURNING " << logch << endl;
        return (Double_t) (17.5 * logch);
      case 2:
        logch = TMath::Log( 0.136 * (chdiv + 0.1854) );
        //      return 1.181 + ( 7.94 * logch ); // first test
        return (chdiv > 0.1 && chdiv < 3.5) ?
          (Double_t) ( ( 2.7 - ( 3.3 * chdiv ) )  * logch ) : 
          -999.;
      default:
        cerr << "FROOT::TofinoZetaFromCharge ---> Data-taking " << dtak << " not available." << endl;
        return 0.;
      }
    }
  
  inline Double_t TofoneZetaFromTime(Int_t dtak,const Double_t &tdcE,const Double_t &tdcP)
    {
      switch(dtak){
      case 1:
        return (Double_t) ( (  tdcP -  tdcE ) / (2 ) * 16.639 );
      case 2:
        return (Double_t) ( (  tdcP -  tdcE ) / (2 ) * 16.639 );
      default:
        cerr << "FROOT::TofoneZetaFromTime ---> Data-taking " << dtak << " not available." << endl;
        return 0.;
      }
    }


  /*   Double_t TofZetaGeoAdjust(const Int_t &layer); // effective light propagation speed */
  /*   Double_t TofZetaGeoAdjust(const E_Fnd_Layer &layer); // effective light propagation speed */
  
  Double_t LmdZetaGeoAdjust(const Int_t &layer);
  Double_t LmdZetaGeoAdjust(const E_Fnd_Layer &layer);
  
  static const Int_t K_N_STB_CROWNS   =   6;   // STB: Number of Stb crowns
  static const Int_t K_N_STB_TUBES    = 404;   // STB: Number of Stb tubes/crown

  // FEE description
  enum E_Fnd_Gts_Constants{
    K_N_GTS_SELECTORS  =  2,    // N_Words in Trigger Selector (gated with TOFINO low/high thr.)
    K_N_GTS_TRIG_TYPES = 12,    // Number of trigger types
    K_N_GTS_P_UNITS    =  4,    // Number of Words in Trigger Selector (3 for the 2003 data-taking)
    K_N_GTS_SCALER_CHANNELS = 16, // Number of Channels/Scaler-module
    K_N_GTS_SCALER_MODULES  = 5,  // Number of Scaler Modules
    K_N_GTS_MALU      = 3,     // Number of MALU modules
  };
  
  enum E_Fnd_Gts_TrigTypes{
    K_TRIG_HYP      = 0,
    K_TRIG_BHABHA   = 1,
    K_TRIG_BTB_LOW  = 2,
    K_TRIG_OR_LOW   = 3,
    K_TRIG_BTB_HIGH = 4,
    K_TRIG_ORtofino_ORtofone = 5,
    K_TRIG_LASER    = 6,
    K_TRIG_PULSER   = 7,
    K_TRIG_TCALIB   = 8,
    K_TRIG_ORtofone = 9,
    K_TRIG_MULTtofone = 10,
    K_TRIG_BTB_LOW_ORtofone = 11,
  };
  
  TString TriggerType(E_Fnd_Gts_TrigTypes type);

  static const Int_t K_N_Tof_AdcMod =  9;  // TOF: Number of ADC modules
  static const Int_t K_N_Tof_AdcCha = 64;  // TOF: Number of ADC channels for each module
  static const Int_t K_N_Tof_TdcMod =  6;  // TOF: Number of TDC modules
  static const Int_t K_N_Tof_TdcCha = 96;  // TOF: Number of TDC channels for each module
  
  enum E_Fnd_Sil_Hardware{
    K_N_Sil_Crams = 27,    // SIL: Number of CRAMS (15 OSM + 12 ISM)
    K_N_Sil_Sects =  2,    // SIL: Number of Sections for each CRAM
    K_N_Sil_Sides = 3,     // SIL: Number of SIDES for each Module (see E_Fnd_Sil_Side)
    K_N_Sil_AdcCha = 1024, // SIL: Number of ADC channels for each section of ADC
    K_N_Sil_AdcChips = 8, // SIL: Number of Chips for each section of ADC
    K_N_Sil_Strips = 1920, // SIL: Max number of strips for both side
    K_N_Sil_Phi_Strips = 1021, // SIL: Number of strips for Phi side
    K_N_Sil_Z_Strips = 1920, // SIL: Number of strips for Z Side
    K_N_Sil_ChaOnChip = 128, // SIL: Number of ADC Cannels for each Chip
    K_N_Sil_Modules = 10,  // Number of hybrid modules (OSIM) (also for ISIM [8])
    K_N_Sil_FixPede = 50,  // Fix Pedestal to be structed from signals 
    K_N_Sil_MulNoise = 10,  // Noise Multiplier Constant (Noise has to be divided by this value) 
    K_N_Sil_Sigma_Cut = 3,  // Low Threshold for Cluster Finding
    K_N_Sil_Sigma_Pre = 5,  // High Threshold for Cluster Finding
    K_N_Sil_Noise_Cut = 8,  // Noise Threshold ( * 10 ) for Cluster Finding  
  };
  
  static const Int_t K_Sil_Crams_BaseAddress_03 = 0xD0A0;    // Base address used by microstrips CRAMS (data-takink 2003)
  static const Int_t K_Sil_Crams_BaseAddress_06 = 0xA0;    // Base address used by microstrips CRAMS (data-takink 2003)
  //  static const Int_t K_N_Sil_Crams = 27;    // SIL: Number of CRAMS (15 OSM + 12 ISM)
  //  static const Int_t K_N_Sil_Sects =  2;     // SIL: Number of Sections for each CRAM
  //  static const Int_t K_N_Sil_Sides = 3;     // SIL: Number of SIDES for each Module (0=Phi, 1 = Za, 2 = Zb)
  //  static const Int_t K_N_Sil_AdcCha = 1024;  // SIL: Number of ADC channels for each section of ADC
  //  static const Int_t K_N_Sil_Chips = 8;     // SIL: Number of CHIPS for each Module
  
  static const Int_t K_N_Lmd_AdcMod =  9;  // LMD: Number of ADC modules
  static const Int_t K_N_Lmd_AdcCha = 64;  // LMD: Number of ADC channels/module
  static const Int_t K_N_Lmd_TdcMod =  9;  // LMD: Number of TDC modules
  static const Int_t K_N_Lmd_TdcCha = 96;  // LMD: Number of TDC channels/module
  
  static const Int_t K_N_Stb_Crates =  2;   // STB: Number of TDC crates
  static const Int_t K_N_Stb_Mod   =  21;   // STB: Number of TDC modules/crate
  static const Int_t K_N_Stb_Cha   =  96;   // STB: Number of TDC channels/module

  // Raw data and equipments constants
#define FIN_RAW_DATA_SOCK_LEN 0x10000
#define FIN_RAW_DATA_BUF_SIZE 0x12000
  //#define FIN_DAQ_RAW_UDP_PORT 2007

  enum E_Fnd_DaqRaw_Udp_Ports {
    FIN_DAQ_RAW_UDP_PORT = 2007,
    FIN_GTS_DAQ_RAW_UDP_PORT = 2001, 
    FIN_TOF_DAQ_RAW_UDP_PORT = 2002,
    FIN_SIL_DAQ_RAW_UDP_PORT = 2003,
    FIN_LMD_DAQ_RAW_UDP_PORT = 2004,
    FIN_STB_DAQ_RAW_UDP_PORT = 2005,
  };

  /*   enum EDaqStatus { // for monitors "K_DAQ_Active" means stopped (active but not running) */
  /*     K_DAQ_Active = 0, */
  /*     K_DAQ_Crashed = 1, */
  /*     K_DAQ_Running  = 5, */
  /*     K_DAQ_NotMonitored = 6, */
  /*   }; */
  
  enum E_Fnd_Raw_Header_Struct {  // GLOBAL EVENT HEADER
    E_FndRawHead_Length =  0,
    E_FndRawHead_Nev_Hw =  1, // starts from 0
    E_FndRawHead_Nev_Sw =  2, // starts from 1
    E_FndRawHead_RunTyp =  3,
    E_FndRawHead_RunNum =  4,
    E_FndRawHead_RStart =  5,
    E_FndRawHead_TElaps =  6,
    E_FndRawHead_GTSptr =  7,
    E_FndRawHead_TOFptr =  8,
    E_FndRawHead_ISIptr =  9,
    E_FndRawHead_OSIptr = 10,
    E_FndRawHead_LMDptr = 11,
    E_FndRawHead_STBptr = 12,
    E_FndRawHead_DAQmsg = 15, // see EDaqStatus for details
  };
  

  static const UInt_t K_MAX_EQP_LEN = 100000; // maximum length for every equipment (to be checked)
  enum {
    //    K_SecondsPerDay = 86400,
    k_EvHeaderLen   = 16,      // length of the Global Event Header
    K_VmeScalBufLen = 82,      // length of the VME scaler buffers in total */
    K_GtsBufLen     = 36,      // length of the GTS buffer
  };

  enum EFndDaqDetectors { FIN_GTS = 0, FIN_TOF, FIN_ISM, FIN_OSM, FIN_LMD, FIN_STB }; // description of all acquired detectors
  enum EFndDetNameMode{ FIN_D_MOD_SHORT = 0, FIN_D_MOD_HDT, FIN_D_MOD_COMPLETE }; // SHORT: 3 chars, HDT: hdt branch name, COMPLETE: complete name
  TString AcquiredDetName(Int_t det,Int_t mode = 0); // det : see FROOT::EFndDaqDetectors ; mode: see FROOT::EFndDetNameMode

  // database
  static const Int_t K_N_DB_HOSTS = 3;
  TString DB_Host_Name(Int_t id);

  // monitoring constants
  //  static const Int_t K_N_RUN_TYPES = 7;
  static const Int_t K_N_FND_MON_DETECTORS = 5; // number of monitored detectors
  TString RunType_Name(Int_t id);
  TString MonDetName(Int_t i);

  enum EFndOnlineFlags { ONL_OFF = 0, ONL_GTS, ONL_TOF, ONL_ISM, ONL_OSM, ONL_LMD, ONL_STB, ONL_ALL };
  enum EFndRunTypes { RT_FINU = 0, RT_COSM, RT_PULS, RT_PEDE, RT_CALI, RT_PLAT, RT_ONLM }; // description of all monitored detectors
  enum EFndMonDetectors { D_GTS = 0, D_TOF, D_SIL, D_LMD, D_STB }; // description of all monitored detectors
  enum EFndDevice { DEV_DISK = 0, DEV_TAPE, DEV_SOCKET};
  enum EFndDBFetchSource { K_DB_SOURCE_HOST = 0, K_DB_SOURCE_FILE }; // K_DB_SOURCE_HOST requires a previous connection

  static const Int_t K_MAX_BINS_ADC = 4000; // used to prevent overfull of memory
  static const Int_t K_MAX_BINS_TDC = 4000; // used to prevent overfull of memory

#ifdef _FND_ONL_USE_MAP_FILES_
  // --- Shared memories management (be very careful!)
  // --- sizes are expressed in MB
  const Int_t K_GtsMapSize = 1;     // GTS
  const Int_t K_TofMapSize = 20;    // TOF
  const Int_t K_TofAdcMapSize = 30;
  const Int_t K_TofTdcMapSize = 30;
  const Int_t K_IsimMapSize = 30;   // SIL
  const Int_t K_OsimMapSize = 30;
  const Int_t K_LmdMapSize = 5;     // LMD
  const Int_t K_LmdIadcMapSize = 5;
  const Int_t K_LmdItdcMapSize = 5;
  const Int_t K_LmdOadcMapSize = 7;
  const Int_t K_LmdOtdcMapSize = 7;
  const Int_t K_StbMapSize = 3;    // STB
  const Int_t K_StbC1MapSize = 5;
  const Int_t K_StbC2MapSize = 5;
  const Int_t K_StbC3MapSize = 5;
  const Int_t K_StbC4MapSize = 5;
  const Int_t K_StbC5MapSize = 5;
  const Int_t K_StbC6MapSize = 5;
#endif  

  TString BuildRunName(const TString &run_type,const Int_t run_num,Bool_t use_subdir=kFALSE);
#if defined _FND_OUTPUTS_USE_SUBDIR
  // method used only if sub-dir support is enabled
  Int_t CreateGrpSubDir(const TString &run_type,const Int_t run_num,const TString &start_pth);
#endif

  TString DecodeRunType(UInt_t r_type_raw);

  Int_t CheckFileExistence(const TString &filename); // 1 if file exists
  // ---
  Float_t GetRamUsage(Bool_t verbose=kFALSE); // return percent of used RAM
  //
  enum E_FROOT_MEM_DESCR {
    E_FROOT_MemRes   = 0,
    E_FROOT_MemVirt  = 1
    /*     E_FROOT_MemTot   = 2 */
  };
  Float_t GetProcMemUsage(E_FROOT_MEM_DESCR mode=E_FROOT_MemVirt,Bool_t verbose=kFALSE);
  // ---

  void CompleteString(TString &str, Int_t size, const char *add_char, Bool_t after);
  // add the content of add_char n-times (until size is reached),
  // according to the boolean "after" (true: append; false: prepend)
  
  // wrapper function for TSystem->ConcatFileName() to suppress memory leaks
  TString ConcatFileName(const char *dir, const char *name);

  // convert two 32-bit words into a 64-bit quad.
  ULong64_t Convert64(UInt_t high, UInt_t low);

  // extract a bit from a UInt_t (32-bit) number
  UShort_t ExtractBit(const UInt_t &number, const UInt_t bit,const UInt_t limit);

  // wrapper function for TSystem->ExpandPathName() to suppress memory leaks
  TString ExpandPathName(const char *path);

  // convert an IP-address string to integer (for socket connections), in host
  // byte order (i.e. LSB first on Intel machines)
  Int_t Ip2Int(const char *ip);
  
  void SayToUser(const TString &Message, Int_t ntimes=1);

  void TerminateFroot(Int_t arg=0,const TString &Error=0);
}

// Inline implementations

// the following lines are required in order to compile under Mac-OS
//#ifdef __CINT__
#if !defined(linux) && !defined(__linux) && !defined(__linux__)
#undef __GNUC__
#endif

#if !defined(__CINT__)
#include <netinet/in.h>           // for in_addr_t
#include <arpa/inet.h>            // for inet_addr(), ntohl()
#endif

#include <TSystem.h>
#include <TInterpreter.h>
#include <TROOT.h>
#include "Varargs.h" // used by Printf method


#if defined(USE_BOOST)
#  include <boost/scoped_array.hpp> // for boost::scoped_array template class
#endif

inline TString FROOT::GetFrootVersion() { return "9.01/02"; }
inline Float_t FROOT::GetFrootVersionID() { return 901.02; }

inline Double_t FROOT::LmdZetaGeoAdjust(const Int_t &layer){
  return LmdZetaGeoAdjust((E_Fnd_Layer)layer);
}

inline Double_t FROOT::LmdZetaGeoAdjust(const E_Fnd_Layer &layer){
  switch (layer){
  case E_FIN_INNER_LAYER: return 58.0;
  case E_FIN_OUTER_LAYER: return 88.04;
  default:
    gROOT->Error("FROOT::LmdZetaGeoAdjust","Layer \"%d\" not available",(Int_t)(layer) );
    return -1;
  } 
}

inline  TString FROOT::TriggerType(E_Fnd_Gts_TrigTypes type){
  switch(type){
  case K_TRIG_HYP: return "HYPE";
  case K_TRIG_BHABHA: return "BHABHA";
  case K_TRIG_BTB_LOW: return "BTB_LowThreshold";
  case K_TRIG_OR_LOW: return "OR_tofino_LowThreshold";
  case K_TRIG_BTB_HIGH: return "BTB_HighThreshold";
  case K_TRIG_ORtofino_ORtofone: return "OR_tofino_And_OR_tofone";
  case K_TRIG_LASER: return "LASER";
  case K_TRIG_PULSER: return "PULSER";
  case K_TRIG_TCALIB: return "Time_Calibration";
  case K_TRIG_ORtofone: return "OR_tofone";
  case K_TRIG_MULTtofone: return "MULT_tofone > 1";
  case K_TRIG_BTB_LOW_ORtofone: return "BTB_LowThreshold_And_OR_tofone";
    default: gROOT->Warning("FROOT::TriggerType","Trigger id not defined (%d)",type); return "";
  }
}

inline TString FROOT::SilSide_Name(Int_t id)
{
  
  switch (id){
  case (Int_t) E_FIN_SIL_SIDE_PH: return "PHI";
  case (Int_t) E_FIN_SIL_SIDE_ZA: return "ZA";
  case (Int_t) E_FIN_SIL_SIDE_ZB: return "ZB";
  default: return "";
  }
  
}

inline TString FROOT::DB_Host_Name(Int_t id)
{
  // check the K_N_DB_HOSTS constant
  // before modyfying the following entries
  switch (id){
  case 0: return "fnddiskfe.lnf.infn.it";
  case 1: return "localhost";
  case 2: return "tozsxl.to.infn.it";
  default: return "localhost";
  }
}

inline TString FROOT::RunType_Name(Int_t id)
{
  // before modyfying the following entries
  switch (id){
  case RT_FINU: return "FINU";
  case RT_COSM: return "COSM";
  case RT_PULS: return "PULS";
  case RT_PEDE: return "PEDE";
  case RT_CALI: return "CALI";
  case RT_ONLM: return "ONLM";
  case RT_PLAT: return "PLAT";
    //  case RT_BHAB: return "BHAB";
  default: return "ONLM";
  }
}

inline TString FROOT::MonDetName(Int_t i) {
  switch(i){
  case D_GTS: return "GTS";
  case D_TOF: return "TOF";
  case D_SIL: return "SIL";
  case D_LMD: return "LMD";
  case D_STB: return "STB";
  default: return "BUG"; // this case should never occur
  }
}

inline TString FROOT::AcquiredDetName(Int_t det,Int_t mode){
  // det : see FROOT::EFndDaqDetectors
  // mode: see FROOT::EFndDetNameMode

  switch(det){
  case FIN_GTS: 
    switch(mode){ 
    case FIN_D_MOD_SHORT: return "GTS"; 
    case FIN_D_MOD_HDT : return "fHGts";
    case FIN_D_MOD_COMPLETE: return "Global Trigger Supervisor";
    default: return "BUG"; // this case should never occur
    }
  case FIN_TOF: 
    switch(mode){ 
    case FIN_D_MOD_SHORT: return "TOF"; 
    case FIN_D_MOD_HDT : return "fHTof";
    case FIN_D_MOD_COMPLETE: return "Time Of Flight system";
    default: return "BUG"; // this case should never occur
    }
  case FIN_ISM: 
    switch(mode){ 
    case FIN_D_MOD_SHORT: return "ISM"; 
    case FIN_D_MOD_HDT : return "fHIsm";
    case FIN_D_MOD_COMPLETE: return "Isim";
    default: return "BUG"; // this case should never occur
    }
  case FIN_OSM: 
    switch(mode){ 
    case FIN_D_MOD_SHORT: return "OSM"; 
    case FIN_D_MOD_HDT : return "fHOsm";
    case FIN_D_MOD_COMPLETE: return "Osim";
    default: return "BUG"; // this case should never occur
    }
  case FIN_LMD: 
    switch(mode){ 
    case FIN_D_MOD_SHORT: return "LMD"; 
    case FIN_D_MOD_HDT : return "fHLmd";
    case FIN_D_MOD_COMPLETE: return "Low Mass Drift Chambers";
    default: return "BUG"; // this case should never occur
    }
  case FIN_STB: 
    switch(mode){ 
    case FIN_D_MOD_SHORT: return "STB"; 
    case FIN_D_MOD_HDT : return "fHStb";
    case FIN_D_MOD_COMPLETE: return "Straw Tubes";
    default: return "BUG"; // this case should never occur
    }
  default: return "BUG"; // this case should never occur
  }  
}

inline TString FROOT::DecodeRunType(UInt_t r_type_raw){

  char r_type[5]="";
  r_type[0]=r_type_raw  & 0xff;
  r_type[1]=(r_type_raw & 0xff00)>>8;
  r_type[2]=(r_type_raw & 0xff0000)>>16;
  r_type[3]=(r_type_raw & 0xff000000)>>24;
  r_type[4]='\0';
  return TString(r_type);
}

inline TString FROOT::BuildRunName(const TString &run_type,const Int_t run_num,Bool_t use_subdir)
{
  // used to build the run-filename (without extension)
  // starting from run-type and run-number
  
  Bool_t consider_run_type = kFALSE; // hard-coded

  TString str;
  if(run_num>=0) str.Form("%d",run_num);
  else  str = ""+0; // needed in online-mode
  CompleteString(str,5,"0",kFALSE);
  str.Prepend(run_type);
  
  if(use_subdir){
    TString subdir = "";
    UInt_t numdir = 1000 * (UInt_t) (run_num / 1000);
    TString strn;
    strn.Form("%u",numdir);
    CompleteString(strn,5,"0",kFALSE);

    if(consider_run_type) subdir.Form("run_group_%s_%s/",run_type.Data(),strn.Data());
    else subdir.Form("run_group_%s/",strn.Data());

    str.Prepend(subdir);
  }
  return str;
}

#if defined _FND_OUTPUTS_USE_SUBDIR
inline Int_t FROOT::CreateGrpSubDir(const TString &run_type,const Int_t run_num,const TString &start_pth){
  // this method is used only if sub-dir support is enabled
  // - environmental variables are accepted
  // - a check on directory existence is performed first
  // 
  // return value:
  //               0: (ok)    directory not found and created
  //               1: (ok)    directory found (already existing)
  //              -1: (error) start_pth does not exist
  //              -2: (error) can not create directory
  //  
  // the consider_run_type variable (hard-coded) can be used in order
  //  to separate different run-types.
  
  Bool_t consider_run_type = kFALSE;

  TString st_pt_cmp = ExpandPathName(start_pth);
  if(st_pt_cmp.IsNull() || gSystem->AccessPathName(st_pt_cmp) ){
    gROOT->Error("FROOT::CreateGrpSubDir","Start Path not found (\"%s\")",st_pt_cmp.Data());
    return -1;
  }

  // remove "/" if found at the end of the given path
  if( st_pt_cmp.EndsWith("/") ) st_pt_cmp.Resize(st_pt_cmp.Sizeof()-2);

  TString ndir = "";
  UInt_t numdir = 1000 * (UInt_t) (run_num / 1000);
  TString strn;
  strn.Form("%u",numdir);
  CompleteString(strn,5,"0",kFALSE);

  if(consider_run_type) ndir.Form("%s/run_group_%s_%s",st_pt_cmp.Data(),run_type.Data(),strn.Data());
  else ndir.Form("%s/run_group_%s",st_pt_cmp.Data(),strn.Data());

  if( !gSystem->AccessPathName(ndir) ){
    gROOT->Info("FROOT::CreateGrpSubDir","directory \"%s\" already existing.",ndir.Data());
    return 1;
  }

  Int_t res = gSystem->MakeDirectory(ndir);
  if(res != 0) {
    gROOT->Error("FROOT::CreateGrpSubDir","Can not create directory \"%s\"",ndir.Data());
    return -2;
  }
  return 0;
}
#endif

inline Int_t FROOT::CheckFileExistence(const TString &filename) {
  // 0 if file does not exist
  // 1 if file exists

  Bool_t filefound = kTRUE;
  if (gSystem->AccessPathName(ExpandPathName(filename)) && gSystem->AccessPathName(ExpandPathName(filename + ".gz")))
    filefound = kFALSE;
  if (!filefound) {
    gROOT->Warning("FROOT::CheckFileExistence", "file \"%s\" not found.",filename.Data());
    return 0;
  }
  return 1;
}

inline Float_t FROOT::GetRamUsage(Bool_t verbose){ 
  // return percent of used RAM
  MemInfo_t *im = new MemInfo_t();
  gSystem->GetMemInfo(im);
  Float_t tot = (Float_t)im->fMemTotal;
  Float_t used = (Float_t)im->fMemUsed;
  Float_t perc = 100. * (used / tot);
  if(verbose) cout << "used memory: " << used << " (" << perc << " %)" << endl;
  delete im; 
  return perc;
}

inline Float_t FROOT::GetProcMemUsage(E_FROOT_MEM_DESCR mode,Bool_t verbose){ 
  // return value:
  //              >=0 : percent of memory used by current process
  //               -1 : error
  MemInfo_t *im = new MemInfo_t();
  gSystem->GetMemInfo(im);
  ProcInfo_t *ipr = new ProcInfo_t();
  gSystem->GetProcInfo(ipr);

  Float_t tot = (Float_t)im->fMemTotal;
  Float_t mem = 0;
  TString descr_str = "";
  Float_t perc = 0;
  
  switch(mode){
  case E_FROOT_MemRes: 
    descr_str = "resident";
    mem = (Float_t)ipr->fMemResident;
    break;
  case E_FROOT_MemVirt:
    descr_str = "virtual";
    mem = (Float_t)(ipr->fMemVirtual);
    break;
  default:
    gROOT->Error("FROOT::GetProcMemUsage","Wrong argument: %d",(Int_t)(mode) );
    break;
  }
  if(mem < 0){
    gROOT->Error("FROOT::GetProcMemUsage","Negative value obtained: %f",mem );
    return -1;
  }
  mem = mem / 1024.; // MB
  //
  perc = 100. * ( mem / tot);
  if(verbose) cout << descr_str.Data() << " memory: " << mem << " (" << perc << " %)" << endl;
  //
  delete im; 
  delete ipr; 
  return perc;
}

inline void FROOT::CompleteString(TString &str, Int_t size, const char *add_char, Bool_t after)
{
  while (str.Sizeof() < size + 1) {
    if (after)
      str.Append(add_char);
    else
      str.Prepend(add_char);
  }
}

inline TString FROOT::ConcatFileName(const char *dir, const char *name)
{
#if defined(USE_BOOST)
  boost::scoped_array<const char> s(gSystem->ConcatFileName(dir, name));
  return TString(s.get());
#else
  const char *s = gSystem->ConcatFileName(dir, name);
  TString ret = s;
  delete[] s;
  return ret;
#endif
}

inline ULong64_t FROOT::Convert64(UInt_t high, UInt_t low)
{
  return ((ULong64_t) high << (CHAR_BIT * sizeof(UInt_t))) | low;
}

inline UShort_t FROOT::ExtractBit(const UInt_t &number, const UInt_t bit,const UInt_t limit){
  // extract a bit from a UInt_t (32-bit) number
  // bit range [0;limit-1]
  
  if(bit > limit-1){
    gROOT->Error("ExtractBit","requested bit (%u) not available (limit=%u)",bit,limit); return 0;
  }
  
  UShort_t result = (UShort_t) ( (number & ((UInt_t)TMath::Power(2,bit))) >> bit );
  return result;
}


inline TString FROOT::ExpandPathName(const char *path)
{
#if defined(USE_BOOST)
  boost::scoped_array<const char> s(gSystem->ExpandPathName(path));
  return TString(s.get());
#else
  const char *s = gSystem->ExpandPathName(path);
  TString ret = s;
  delete[] s;
  return ret;
#endif
}

inline Int_t FROOT::Ip2Int(const char *ip)
{
  in_addr_t addr = inet_addr(ip);
  return ntohl(addr);
}

inline void FROOT::SayToUser(const TString &Message, Int_t ntimes){
  
  TString command;
  command.Form("echo \'(SayText \"%s\")\' |festival --pipe",Message.Data());
  
  for(Int_t i=0;i<ntimes;i++){
    gSystem->Exec(command);
    if(ntimes>1) usleep(500000);
  }
  
}

inline void FROOT::TerminateFroot(Int_t arg,const TString &Error)
{
  Printf("");
  Printf(" --------------------------------------------------");

  if(Error.IsNull()){
    gROOT->Error("FROOT termination","fROOT has been terminated due to an internal error.");
    Printf("fROOT has been terminated due to an internal error.");
  }
  else gROOT->Error("FROOT termination",Error.Data());
  Printf(" --------------------------------------------------");
  Printf("");
  gSystem->Exit(arg);
  gApplication->Terminate(arg); // I want to be realy sure to quit
  gInterpreter->ProcessLine(".q"); // not really needed
}


#endif // FROOT_FROOT

---