PREAN/TFndPrean.cxx

// @(#)fROOT/PREAN:$Name:  $:$Id: TFndPrean.cxx,v 1.91 2007/10/02 09:00:08 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2005/06/24

//                                                                             //
//                      PRE-ANALYSIS IMPLEMENTATION                            //
//                                                                             //
//  All operations and calculations required by the preanalysis process are    //
//  implemented in this class:                                                 //
//    1) LUMINOSITY (offline evaluation)                                       //
//    2) HYPERNUCLEI acquisition/reconstruction quality                        //
//    2) BHABHA beam/acquisition/reconstruction quality                        //
//                                                                             //
//  Event buffer,  socket connection, and event processing are handled by the  //
//  preanalysis manger (see TFndPreanMan, daughter of TFndRun).                //
//                                                                             //
//  The ZEBRA structure is accessed through fProcessRec                        //
//  (pointer to TFndProcessRec and data member of TFndRun).                    //
//                                                                             //
//  IMPORTANT NOTE:                                                            //
//    Use of short-tracks, kalman filter, and other setting for fidarc are set //
//    in the TFndProcessRec.h file                                             //
//                                                                             //

#include <Riostream.h>
#include <TDatime.h>
#include <TMath.h>
#include <TCondition.h>

#include "TFndEnv.h"
#include "TFndPrean.h"

#include "TStreamerInfo.h"

ClassImp(TFndPrean)

TClonesArray *TFndPrean::fgKminTracks = 0;
TClonesArray *TFndPrean::fgKpluTracks = 0;
TClonesArray *TFndPrean::fgVertices = 0;

//_____________________________
TFndPrean::TFndPrean(Int_t debug_lev)
  : fDebugLev(debug_lev),fTrkStream(-1),
    fScalTree(),fGesTree(),fBabaTree(),fBhabhaTree(),fHypeTree(),
    fCurPreanFile(),
    fCurTrack(),fCurVertex()
{
  // default constructor: simply initialize data members

  fForeseenSign[0] = -1;
  fForeseenSign[1] =  1;

  if (!fgKminTracks) fgKminTracks = new TClonesArray("TFndTrack",5);
  fTracks_Kmin = fgKminTracks;

  if (!fgKpluTracks) fgKpluTracks = new TClonesArray("TFndTrack",5);
  fTracks_Kplu = fgKpluTracks;

  if (!fgVertices) fgVertices = new TClonesArray("TFndVertex",4);
  fVertices = fgVertices;

}

//_____________________________
TFndPrean::~TFndPrean(){
  Finish();

  delete fCurTrack;
  delete fCurVertex;

  fTracks_Kmin->Delete();
  fTracks_Kplu->Delete();
  fVertices->Delete();

  delete fScalTree;
  delete fGesTree;
  delete fBabaTree;
  delete fBhabhaTree;
  delete fHypeTree;

}

//_____________________________
void TFndPrean::Init(Bool_t is_online){
  // Initialize all preanalysis processes


  // --- old stuff
  //   TFndEnv *env = TFndEnv::Instance();
  //   fPathDafne = env->GetValue("froot.PreAnalysis.PathDafne", "/data02/fnddafne", "FND_PREAN_SHR");
  //   if(fDebugLev) Info("Init", "FND_PREAN_SHR is \"%s\"", fPathDafne.Data());  
  // ---

  fIsOnline = is_online;
  fTrkStream = -1;
  //
  fCurTrack = new TFndTrack();
  fCurVertex = new TFndVertex();
  //
  Reset();
  InitTrees();
}

//_____________________________
void TFndPrean::Reset(){
  // empty all trees, reset rates evaluation variables
  // no change is applied to current date/time, paths and files (ofstream)
  
  ResetDataVariables();
  
  // trees reset
  if(fScalTree)   fScalTree->Reset();
  if(fGesTree)    fGesTree->Reset();
  if(fBabaTree)   fBabaTree->Reset();
  if(fBhabhaTree) fBhabhaTree->Reset();
  if(fHypeTree)   fHypeTree->Reset();

  // clear track lists
  fTracks_Kmin->Clear();
  fTracks_Kplu->Clear();
  fVertices->Clear();

  fCurTrack->Reset();
  fCurVertex->Reset();

  CloseCurrentSourceFile(); // trees (got from file) are deleted automatically

}

//_____________________________
void TFndPrean::ResetDataVariables(){
  // reset all variables used by trees

  Float_t in_val_floats = -9999.;
  Int_t in_val_ints = -9999;
  UInt_t in_val_uints = 9999;

  // --- SCALERS tree variables
  bzero(fScal0,sizeof(fScal0));
  bzero(fScal1,sizeof(fScal1));
  bzero(fScal2,sizeof(fScal2));
  bzero(fScal3,sizeof(fScal3));
  bzero(fScal4,sizeof(fScal4));
  
  fScalEvNum = in_val_ints;
  for(Int_t i=0; i < (Int_t)E_Scal_Inhib_End ; i++){
    fScal_Time[i] = in_val_ints;
    fScal_HYP[i]  = in_val_ints;
    fScal_BHA[i]  = in_val_ints;
    fScal_ORtofino_MB[i] = in_val_ints;
    fScal_ORtofone[i]    = in_val_ints;
  }  
  

  // --- GES variables
  fGesEvNum    = in_val_ints;
  fGesTrigType = in_val_ints;
  fGesEvTime   = in_val_uints; // unsigned
  fGesNentryBhabha = in_val_ints;
  fGesNentryHype = in_val_ints;
  // --- BABA tree (not used)

  // --- BHABHA tree variables
  fBhaEvNum = -1;

  fForeseenSign[0] = -1;
  fForeseenSign[1] =  1;
  
  fBhaVertImpossible = 1;
  fBhaVertDoubtful = 1;
  for(Int_t i=0;i<3;i++) fBhaVertPos[i] = in_val_floats;
  for(Int_t i=0;i<2;i++){
    fBhaMom[i] = in_val_floats;
    fBhaIsLong[i] = 0; // this is a boolean variable!
    fBhaPipeAngle[i] = in_val_floats;
    fBhaTofiTime[i] = in_val_floats;
    fBhaTofoTime[i] = in_val_floats;
    fBhaTrackLength[i] = in_val_floats;
    fBhaGeoPRradius[i] = in_val_floats;
    fBhaGeoFitPoint_X[i] = in_val_floats;
    fBhaGeoFitPoint_Y[i] = in_val_floats;
    fBhaGeoFitPoint_Z[i] = in_val_floats;
    fBhaGeoFitDirCos_X[i] = in_val_floats;
    fBhaGeoFitDirCos_Y[i] = in_val_floats;
    fBhaGeoFitDirCos_Z[i] = in_val_floats;
  }
  fBhaInvMass_EpluEmin = in_val_floats;
  fBhaInvMass_PIpluPImin = in_val_floats;
  fBhaTotalMomentum = in_val_floats;
  fBhaAngle = in_val_floats;
  
  // --- HYPE tree variables
  fHypEvNum = -1;
  fHyp_PattRec_Err = in_val_ints;
  for(Int_t i=0;i<3;i++) fHyp_PhiDecayPos[i] = in_val_floats;
  for(Int_t i=0;i<2;i++){
    //    fHypStopInTgt[i] = 0;
    fHypStopID[i] = 0;
    fHypStopTgtNum[i] = in_val_ints;
    fHypStopVolNum[i] = in_val_ints;

    fHyp_K_StopPoint_X[i] = in_val_floats;
    fHyp_K_StopPoint_Y[i] = in_val_floats;
    fHyp_K_StopPoint_Z[i] = in_val_floats;

    fHyp_K_DeDx_Isi[i] = in_val_floats;
    fHyp_K_Vert_Center_X[i] = in_val_floats;
    fHyp_K_Vert_Center_Y[i] = in_val_floats;
    fHyp_K_Vert_Radius[i] = in_val_floats;
  }

  // clear track and vertices lists
  fCurTrack->Reset();
  fCurVertex->Reset();

  fTracks_Kmin->Clear();
  fTracks_Kplu->Clear();
  fVertices->Clear();
  
}

//_____________________________
void TFndPrean::AddTrack(Int_t part_id){

  E_FinPhys_HypePart_ID prt = (E_FinPhys_HypePart_ID) part_id;

  TClonesArray *selected_array;

  switch(prt){
  case FPh_HypKmin_id:
    selected_array = fTracks_Kmin;
    break;
  case FPh_HypKplu_id:
    selected_array = fTracks_Kplu;
    break;
  default: 
    Error("AddTrack","part_id = \"%i\" not accepted! BUG!",part_id);
    TerminateFroot();
    fCurTrack = 0;
    break;
  }
  
  Int_t last_id = selected_array->GetEntries();
  TClonesArray &tmp_container = *selected_array;
  fCurTrack = new(tmp_container[last_id]) TFndTrack();

  return;
}

//_____________________________
void TFndPrean::AddVertex(){
  
  Int_t last_id = fVertices->GetEntries();
  TClonesArray &tmp_container = *fVertices;
  fCurVertex = new(tmp_container[last_id]) TFndVertex();
  
  return;
}

//_____________________________
void TFndPrean::InitTrees(){
  // create all trees and assign branches to variables

  // SCALERS tree: tree filled with the content of scalers (raw-data)
  fScalTree = new TTree("prean_scal_tree","SCALERS Preanalysis tree");
  //
  fScalTree->Branch("ev_num",&fScalEvNum,"/I");
  fScalTree->Branch("time",fScal_Time,"[3]/I");
  fScalTree->Branch("hyp",fScal_HYP,"[3]/I");
  fScalTree->Branch("bha",fScal_BHA,"[3]/I");
  fScalTree->Branch("or_tofino_mb",fScal_ORtofino_MB,"[3]/I");
  fScalTree->Branch("or_tofone",fScal_ORtofone,"[3]/I");
  
  // GES tree: tree filled with general information about the event
  //   (GES: Global Event Structure)
  fGesTree = new TTree("prean_ges_tree","GES Preanalysis tree");
  //
  fGesTree->Branch("ev_num",&fGesEvNum,"/I");
  fGesTree->Branch("trig_type",&fGesTrigType,"/I");
  fGesTree->Branch("ev_time",&fGesEvTime,"/i");
  fGesTree->Branch("bhabha_entry",&fGesNentryBhabha,"/I");
  fGesTree->Branch("hype_entry",&fGesNentryHype,"/I");

  // Baba tree : tree filled by baba reconstruction process (single helix reconstruction)
  fBabaTree = new TTree("prean_baba_tree","BABA Preanalysis tree (single helix)");
  
  // Bhabha tree : tree filled by bhabha reconstruction process (double helix reconstruction)
  fBhabhaTree = new TTree("prean_bhabha_tree","BHABHA Preanalysis tree (double helix)");
  //
  fBhabhaTree->Branch("ev_num",&fBhaEvNum,"/I");
  fBhabhaTree->Branch("vert_impossible",&fBhaVertImpossible,"/O");
  fBhabhaTree->Branch("vert_doubtful",&fBhaVertDoubtful,"/O");
  fBhabhaTree->Branch("vert_pos",fBhaVertPos,"[3]/F");
  //
  fBhabhaTree->Branch("part_mom",fBhaMom,"[2]/F");
  //
  fBhabhaTree->Branch("part_pipe_x",fBhaPipe_X,"[2]/F");
  fBhabhaTree->Branch("part_pipe_y",fBhaPipe_Y,"[2]/F");
  fBhabhaTree->Branch("part_pipe_z",fBhaPipe_Z,"[2]/F");
  //
  fBhabhaTree->Branch("part_cdx",fBhaDirCos_X,"[2]/F");
  fBhabhaTree->Branch("part_cdy",fBhaDirCos_Y,"[2]/F");
  fBhabhaTree->Branch("part_cdz",fBhaDirCos_Z,"[2]/F");
  //
  fBhabhaTree->Branch("long_trk",fBhaIsLong,"[2]/O");
  fBhabhaTree->Branch("pipe_angle",fBhaPipeAngle,"[2]/F");
  // ---
  fBhabhaTree->Branch("tofino_time",fBhaTofiTime,"[2]/F"); // version >= 9.00/01
  fBhabhaTree->Branch("tofone_time",fBhaTofoTime,"[2]/F"); // version >= 9.00/01
  fBhabhaTree->Branch("track_length",fBhaTrackLength,"[2]/F"); // version >= 9.00/02
  // ---
  fBhabhaTree->Branch("inv_mass_e_e",&fBhaInvMass_EpluEmin,"/F");
  fBhabhaTree->Branch("inv_mass_pi_pi",&fBhaInvMass_PIpluPImin,"/F");
  fBhabhaTree->Branch("tot_mom",&fBhaTotalMomentum,"/F");
  fBhabhaTree->Branch("tracks_ang",&fBhaAngle,"/F");

  // added after version 9.00/02
  fBhabhaTree->Branch("pr_radius",fBhaGeoPRradius,"[2]/F"); // version >= 9.00/02
  fBhabhaTree->Branch("fit_point_x",fBhaGeoFitPoint_X,"[2]/F"); // version >= 9.00/02
  fBhabhaTree->Branch("fit_point_y",fBhaGeoFitPoint_Y,"[2]/F"); // version >= 9.00/02
  fBhabhaTree->Branch("fit_point_z",fBhaGeoFitPoint_Z,"[2]/F"); // version >= 9.00/02
  fBhabhaTree->Branch("fit_dircos_x",fBhaGeoFitDirCos_X,"[2]/F"); // version >= 9.00/02
  fBhabhaTree->Branch("fit_dircos_y",fBhaGeoFitDirCos_Y,"[2]/F"); // version >= 9.00/02
  fBhabhaTree->Branch("fit_dircos_z",fBhaGeoFitDirCos_Z,"[2]/F"); // version >= 9.00/02
  
  // Hype tree : tree filled by hype reconstruction process (full reconstruction)
  fHypeTree = new TTree("prean_hype_tree","HYPE Preanalysis tree (full reconstruction)");  
  //
  fHypeTree->Branch("ev_num",&fHypEvNum,"/I");
  fHypeTree->Branch("patt_rec_err",&fHyp_PattRec_Err,"/I");
  fHypeTree->Branch("phi_decay_pos",fHyp_PhiDecayPos,"[3]/F");
  //
  fHypeTree->Branch("stop_id",fHypStopID,    "[2]/I");
  fHypeTree->Branch("stop_tgt_num",fHypStopTgtNum,    "[2]/I");
  fHypeTree->Branch("stop_vol_num",fHypStopVolNum,    "[2]/I");
  //
  fHypeTree->Branch("part_stop_x", fHyp_K_StopPoint_X,"[2]/F");
  fHypeTree->Branch("part_stop_y", fHyp_K_StopPoint_Y,"[2]/F");
  fHypeTree->Branch("part_stop_z", fHyp_K_StopPoint_Z,"[2]/F");
  //
  fHypeTree->Branch("part_dedx_isi",fHyp_K_DeDx_Isi,"[2]/F");
  //
  fHypeTree->Branch("KminTracks","TClonesArray",&fTracks_Kmin); // version >= 9.00/01
  fHypeTree->Branch("KpluTracks","TClonesArray",&fTracks_Kplu); // version >= 9.00/01
  fHypeTree->Branch("Vertices","TClonesArray",&fVertices); // version >= 9.01/02
  // added after version 9.00/02
  fHypeTree->Branch("part_v_center_x",fHyp_K_Vert_Center_X,"[2]/F"); // version >= 9.00/02
  fHypeTree->Branch("part_v_center_y",fHyp_K_Vert_Center_Y,"[2]/F"); // version >= 9.00/02
  fHypeTree->Branch("part_v_radius",fHyp_K_Vert_Radius,"[2]/F"); // version >= 9.00/02
  
}

//____________________________
Int_t TFndPrean::LoadTrees(const TString &fnam){
  // return value:
  //              0: ok (all trees loaded)
  //             -1: file not found
  //             -2: problems while getting trees from file
 
  if(gSystem->AccessPathName(fnam) == 1){
    if(fDebugLev>=1) Warning("LoadTrees","file \"%s\" not found",fnam.Data());
    return -1;
  }

  CloseCurrentSourceFile(); // not really needed, but safe
  fCurPreanFile = new TFile(fnam,"OPEN");

  // --- check streamer version
  TList *lisstr = fCurPreanFile->GetStreamerInfoList();
  TStreamerInfo *infstr = (TStreamerInfo *)(lisstr->FindObject("TFndTrack"));
  if(infstr) fTrkStream =  infstr->GetClassVersion();

  //
  if(fDebugLev>=2)
    Printf("TFndPrean::Reading file \"%s\" (compression level is: %d)",fCurPreanFile->GetName(),fCurPreanFile->GetCompressionLevel());
  else if(fDebugLev==1)
    Printf("TFndPrean::Reading file \"%s\"",fCurPreanFile->GetName());
  else{
    TString r_nam = fnam;
    r_nam.Remove(0,r_nam.Sizeof()-21);
    r_nam.Resize(r_nam.Sizeof()-12);
    //    Printf("Reading run \"%s\"",r_nam.Data());
  }
  //
  
  fScalTree   = (TTree *) fCurPreanFile->Get("prean_scal_tree");
  fGesTree    = (TTree *) fCurPreanFile->Get("prean_ges_tree");
  fBabaTree   = (TTree *) fCurPreanFile->Get("prean_baba_tree");
  fBhabhaTree = (TTree *) fCurPreanFile->Get("prean_bhabha_tree");
  fHypeTree   = (TTree *) fCurPreanFile->Get("prean_hype_tree");  

  // ---
  if(!fScalTree && !fGesTree && !fBabaTree && !fBhabhaTree && !fHypeTree) return -2;

  // --- assign branches to scalers tree
  if(fScalTree){
    if( fScalTree->GetBranch("ev_num") ) fScalTree->SetBranchAddress("ev_num",&fScalEvNum);
    if( fScalTree->GetBranch("time") ) fScalTree->SetBranchAddress("time",fScal_Time);
    if( fScalTree->GetBranch("hyp") ) fScalTree->SetBranchAddress("hyp",fScal_HYP);
    if( fScalTree->GetBranch("bha") ) fScalTree->SetBranchAddress("bha",fScal_BHA);
    if( fScalTree->GetBranch("or_tofino_mb") ) fScalTree->SetBranchAddress("or_tofino_mb",fScal_ORtofino_MB);
    if( fScalTree->GetBranch("or_tofone") ) fScalTree->SetBranchAddress("or_tofone",fScal_ORtofone);
  }

  // --- assign branches to ges tree
  if(fGesTree){
    if( fGesTree->GetBranch("ev_num") )    fGesTree->SetBranchAddress("ev_num",&fGesEvNum);
    if( fGesTree->GetBranch("trig_type") ) fGesTree->SetBranchAddress("trig_type",&fGesTrigType);
    if( fGesTree->GetBranch("ev_time") )   fGesTree->SetBranchAddress("ev_time",&fGesEvTime);
    if( fGesTree->GetBranch("bhabha_entry") ) fGesTree->SetBranchAddress("bhabha_entry",&fGesNentryBhabha);
    if( fGesTree->GetBranch("hype_entry") ) fGesTree->SetBranchAddress("hype_entry",&fGesNentryHype);
  }
  
  // --- assign branches to bhabha tree
  if(fBhabhaTree){
    if( fBhabhaTree->GetBranch("ev_num") )fBhabhaTree->SetBranchAddress("ev_num",&fBhaEvNum);
    fBhabhaTree->SetBranchAddress("vert_impossible",&fBhaVertImpossible);
    fBhabhaTree->SetBranchAddress("vert_doubtful",&fBhaVertDoubtful);
    fBhabhaTree->SetBranchAddress("vert_pos",fBhaVertPos);
    
    fBhabhaTree->SetBranchAddress("part_mom",fBhaMom);
    
    if( fBhabhaTree->GetBranch("part_pipe_x") ) fBhabhaTree->SetBranchAddress("part_pipe_x",fBhaPipe_X);
    if( fBhabhaTree->GetBranch("part_pipe_y") ) fBhabhaTree->SetBranchAddress("part_pipe_y",fBhaPipe_Y);
    if( fBhabhaTree->GetBranch("part_pipe_z") ) fBhabhaTree->SetBranchAddress("part_pipe_z",fBhaPipe_Z);
    
    fBhabhaTree->SetBranchAddress("part_cdx",fBhaDirCos_X);
    fBhabhaTree->SetBranchAddress("part_cdy",fBhaDirCos_Y);
    fBhabhaTree->SetBranchAddress("part_cdz",fBhaDirCos_Z);
    
    fBhabhaTree->SetBranchAddress("long_trk",fBhaIsLong);
    fBhabhaTree->SetBranchAddress("pipe_angle",fBhaPipeAngle);
    
    // --- BHABHA TOF time added after version 9.00/01
    if( fBhabhaTree->GetBranch("tofino_time") ) fBhabhaTree->SetBranchAddress("tofino_time",fBhaTofiTime);
    if( fBhabhaTree->GetBranch("tofone_time") ) fBhabhaTree->SetBranchAddress("tofone_time",fBhaTofoTime);
    if( fBhabhaTree->GetBranch("track_length") ) fBhabhaTree->SetBranchAddress("track_length",fBhaTrackLength); // version >= 9.00/02
    
    fBhabhaTree->SetBranchAddress("inv_mass_e_e",&fBhaInvMass_EpluEmin);
    fBhabhaTree->SetBranchAddress("inv_mass_pi_pi",&fBhaInvMass_PIpluPImin);
    fBhabhaTree->SetBranchAddress("tot_mom",&fBhaTotalMomentum);
    fBhabhaTree->SetBranchAddress("tracks_ang",&fBhaAngle);
    // // version >= 9.00/02
    if( fBhabhaTree->GetBranch("pr_radius") ) fBhabhaTree->SetBranchAddress("pr_radius",fBhaGeoPRradius);
    if( fBhabhaTree->GetBranch("fit_point_x") ) fBhabhaTree->SetBranchAddress("fit_point_x",fBhaGeoFitPoint_X);
    if( fBhabhaTree->GetBranch("fit_point_y") ) fBhabhaTree->SetBranchAddress("fit_point_y",fBhaGeoFitPoint_Y);
    if( fBhabhaTree->GetBranch("fit_point_z") ) fBhabhaTree->SetBranchAddress("fit_point_z",fBhaGeoFitPoint_Z);
    if( fBhabhaTree->GetBranch("fit_dircos_x") ) fBhabhaTree->SetBranchAddress("fit_dircos_x",fBhaGeoFitDirCos_X);
    if( fBhabhaTree->GetBranch("fit_dircos_y") ) fBhabhaTree->SetBranchAddress("fit_dircos_y",fBhaGeoFitDirCos_Y);
    if( fBhabhaTree->GetBranch("fit_dircos_z") ) fBhabhaTree->SetBranchAddress("fit_dircos_z",fBhaGeoFitDirCos_Z);
  }
  
  // --- assign branches to hype tree
  if(fHypeTree){
    if( fHypeTree->GetBranch("ev_num") )fHypeTree->SetBranchAddress("ev_num",&fHypEvNum);
    fHypeTree->SetBranchAddress("patt_rec_err",&fHyp_PattRec_Err);
    fHypeTree->SetBranchAddress("phi_decay_pos",fHyp_PhiDecayPos);
    
    //  fHypeTree->SetBranchAddress("stop_in_tgt",fHypStopInTgt);
    fHypeTree->SetBranchAddress("stop_id",fHypStopID);
    fHypeTree->SetBranchAddress("stop_tgt_num",fHypStopTgtNum);
    fHypeTree->SetBranchAddress("stop_vol_num",fHypStopVolNum);
    
    fHypeTree->SetBranchAddress("part_stop_x",fHyp_K_StopPoint_X);
    fHypeTree->SetBranchAddress("part_stop_y",fHyp_K_StopPoint_Y);
    fHypeTree->SetBranchAddress("part_stop_z",fHyp_K_StopPoint_Z);
    
    if(fHypeTree->GetBranch("part_dedx_isi")) fHypeTree->SetBranchAddress("part_dedx_isi",fHyp_K_DeDx_Isi);
    // --- tracks added after version 9.00/01
    if(fHypeTree->GetBranch("KminTracks")) fHypeTree->SetBranchAddress("KminTracks",&fTracks_Kmin);
    if(fHypeTree->GetBranch("KpluTracks")) fHypeTree->SetBranchAddress("KpluTracks",&fTracks_Kplu);
    if(fHypeTree->GetBranch("Vertices")) fHypeTree->SetBranchAddress("Vertices",&fVertices); // version >= 9.01/02

    // added after version 9.00/02
    if(fHypeTree->GetBranch("part_v_center_x")) fHypeTree->SetBranchAddress("part_v_center_x",fHyp_K_Vert_Center_X);
    if(fHypeTree->GetBranch("part_v_center_y")) fHypeTree->SetBranchAddress("part_v_center_y",fHyp_K_Vert_Center_Y);
    if(fHypeTree->GetBranch("part_v_radius")) fHypeTree->SetBranchAddress("part_v_radius",fHyp_K_Vert_Radius);
  }
  
  return 0;
}

//____________________________
Int_t TFndPrean::CloseCurrentSourceFile(){
  // return value:
  //              0: ok (file closed)
  //             -1: no file defined
  //             -2: file defined, but already closed
  
  if(!fCurPreanFile) return -1;
  if(!fCurPreanFile->IsOpen()) return -2;
  
  fCurPreanFile->Close();
  delete fCurPreanFile;
  fCurPreanFile = 0;  
  
  return 0;
}

//_____________________________
void TFndPrean::SetDeamonBehaviour(){
  // Set class attributes for using it as a deamon
  
  fDebugLev = -1; // suppress all outputs
}

//_____________________________
void TFndPrean::Finish(){
  // Perform ending operations for all preanalysis processes
  
}

//_____________________________
Int_t TFndPrean::SaveTrees(TFile *file){
  // save all trees to the given root-file
  // NOTE: the file is not closed here!
  //
  // return value:
  //              0: ok
  //             -1: null pointer received
  //             -2: received file is not open
  //             -3: received file is not writable

  if(!file){
    Error("SaveTrees","null pointer received");
    return -1;
  }
  if(! file->IsOpen()){
    Error("SaveTrees","file \"%s\" is not open",file->GetName());
    return -2;
  }
  if(! file->IsWritable()){
    Error("SaveTrees","file \"%s\" is not writable",file->GetName());
    return -3;
  }
  
  if(!fScalTree || !fGesTree || !fBabaTree || !fBhabhaTree || !fHypeTree){
    TerminateFroot(0,"Maybe you have just found a BUG (TFndPrean::SaveTrees)");
  }
  
  file->cd();
  //
  fScalTree->Write();
  fGesTree->Write();
  fBabaTree->Write();
  fBhabhaTree->Write();
  fHypeTree->Write();
  //
  file->Purge();  
  return 0;
}

//_____________________________
Int_t TFndPrean::GoToEvent(const Int_t &ev_num,Int_t &mode){
  // find event "ev_num" in every tree
  //  Note: ev_num starts from "1"
  //
  // "mode" is the type:
  //                    -1: Not reconstructed
  //                     0: Bhabha
  //                     1: Hype
  // note that scalers tree is filled with all events
  //
  // return value:
  //               0: ok
  //              -1: error

  mode = -1; // means: not reconstructed event
  Int_t retval = -1;

  //  Info("GoToEvent","Going to event %d",ev_num);
  
  // --- scalers
  if(fScalTree && fScalTree->GetEntries() && ev_num-1 <= fScalTree->GetEntries() ){
    fScalTree->GetEntry(ev_num-1);
    //Printf(" -------> fScalEvNum: %d",fScalEvNum);
    if(fScalEvNum != ev_num) return -1;
    retval = 0;
  }
  
  // --- ges
  if(fGesTree && fGesTree->GetEntries() && ev_num-1 <= fGesTree->GetEntries() ){
    fGesTree->GetEntry(ev_num-1);
    //Printf(" -------> fGesEvNum: %d",fGesEvNum);
    if(fGesEvNum != ev_num) return -1;
    retval = 0;
  }  
  //   Printf(" -------> fGesNentryBhabha: %d",fGesNentryBhabha);
  //   Printf(" -------> fGesNentryHype: %d",fGesNentryHype);  
  
  // --- baba foreseen, but not implemented in pre-analysis
  
  // --- bhabha
  if(fBhabhaTree && fBhabhaTree->GetEntries() > 0 && fBhabhaTree->GetEntries() >= fGesNentryBhabha){
    fBhabhaTree->GetEntry(fGesNentryBhabha-1);
    //Printf(" -------> fBhaEvNum: %d",fBhaEvNum);
    if(fBhaEvNum == ev_num){
      mode = 0;
      retval = 0;
    }
  }
  
  // --- hype
  if(fHypeTree && fHypeTree->GetEntries() > 0 && fHypeTree->GetEntries() >= fGesNentryHype){
    fHypeTree->GetEntry(fGesNentryHype-1);
    //Printf(" -------> fHypEvNum: %d",fHypEvNum);
    if(fHypEvNum == ev_num){
      if(mode != -1){
        Error("GoToEvent","can not be both bhabha and hype! (ev: %d)",ev_num);
        return -1;
      }
      mode = 1;
      retval = 0;
    }
  }
  
  // ---
  return retval;  
}

//_____________________________
void TFndPrean::InspectGES(TFndProcessRec *prec){
  
  Int_t JFGES = prec->GetJFGES();
  if(!JFGES){
    if(fCurLogFile) *fCurLogFile << "InspectGES Warning: JFGES=0" << endl;
    // Warning("AnalyzeBhabha","JFGES=0");
    return;
  }
  
  fGesEvNum = prec->GetIQ(JFGES+2);
  fGesTrigType = prec->GetIQ(JFGES+3);
  // Type of trigger code   (1): Hypernuclear trigger
  //                        (2): Bhabha Trigger
  //                        (3): Cosmic ray trigger
  //                       (11): Both HYP and BHA bits on
  //                             Priority to HYP trigger
  //                       (21): Single track (only MC)
  
  UInt_t rtim = (UInt_t) ( prec->GetIQ(JFGES+4) ); // Unix time of the run
  UInt_t etim = (UInt_t) ( prec->GetIQ(JFGES+5) ); // Time of the event from the run start (s)
  fGesEvTime = (UInt_t) (rtim + etim);
 
}

//_____________________________
void TFndPrean::UpdateGESTree(){
  
  if(fBhabhaTree) fGesNentryBhabha = (Int_t)(fBhabhaTree->GetEntries());
  if(fHypeTree) fGesNentryHype = (Int_t)(fHypeTree->GetEntries());  
  //   Printf("==========> BHA: %d (%d)",(Int_t)fBhabhaTree->GetEntries(),fGesNentryBhabha);
  //   Printf("==========> HYP: %d (%d)",(Int_t)fHypeTree->GetEntries(),fGesNentryHype);
  
  fGesTree->Fill(); 

}

//_____________________________
void TFndPrean::ReadScalers(UInt_t *RawEvent){
  
  // read content of all scalers and evaluate the relative rates
  //          GLOBAL EVENT HEADER: see FROOT::E_Fnd_Raw_Header_Struct              
  //
  //            GTS EVENT BUFFER 
  //
  //     RawEvent[16+0 =16] -----> EVENT LENGTH = HEADER LENGTH + k (k = number of read data)
  //     RawEvent[16+1 =17] -----> EVENT NUMBER (Hardware)
  //     RawEvent[16+2 =18] -----> DETECTOR IDENTIFIER (GTS) 
  //     RawEvent[16+3 =19] -----> RUN NUMBER
  //     RawEvent[16+4 =20] -----> EVENT NUMBER (Software)
  //     RawEvent[16+5 =21] -----> HEADER LENGTH (36) 
  //
  //     RawEvent[16+6 =22] -----> EQUIPMENT  1 POINTER: CORBO
  //     RawEvent[16+8 =24] -----> EQUIPMENT  3 POINTER: VME TRIGGER SELECTOR
  //     RawEvent[16+9 =25] -----> EQUIPMENT  4 POINTER: VME PATTERN UNIT
  //     RawEvent[16+10=26] -----> EQUIPMENT  5 POINTER: VME SCALER
  //     RawEvent[16+31=47] -----> EQUIPMENT 26 POINTER: CAMAC TDC (LECROY 2229)
  //     RawEvent[16+36=52] -----> FIRST DATUM
  //
  //     scp=RawEvent[26]+16
  //
  //     (5) VME SCALER
  //      RawEvent[scp+0] ----> length
  //      RawEvent[scp+1] ----> scaler V1 config. (cascading)
  //      RawEvent[scp+2] ----> MULT 2-7 (HYP)
  //      RawEvent[scp+3] ----> MULT 2-7 (BHA)
  //      RawEvent[scp+4] ----> BTB-MB
  //      RawEvent[scp+5] ----> BTB-EL
  //      RawEvent[scp+6] ----> PC (Prompt Coincidence)
  //      RawEvent[scp+7] ----> Presc BTB-MB
  //      RawEvent[scp+8] ----> OR-MB
  //      RawEvent[scp+9] ----> OR-EL
  //      RawEvent[scp+10] ---> HYP
  //      RawEvent[scp+11] ---> BHA
  //      RawEvent[scp+12] ---> Presc BHA
  //      RawEvent[scp+13] ---> Presc BTB-EL
  //      RawEvent[scp+14] ---> OR-TOFONE
  //      RawEvent[scp+15] ---> Presc OR-MB
  //      RawEvent[scp+16] ---> Total Triggers
  //      RawEvent[scp+17] ---> TIME (100 Hz)
  //
  //      RawEvent[scp+18] ---> scaler V2 config. (cascading)
  //      RawEvent[scp+19] ---> MULT 2-7 (HYP)
  //      RawEvent[scp+20] ---> MULT 2-7 (BHA)
  //      RawEvent[scp+21] ---> BTB-MB
  //      RawEvent[scp+22] ---> BTB-EL
  //      RawEvent[scp+23] ---> PC (Prompt Coincidence)
  //      RawEvent[scp+24] ---> Presc BTB-MB
  //      RawEvent[scp+25] ---> OR-MB
  //      RawEvent[scp+26] ---> OR-EL
  //      RawEvent[scp+27] ---> HYP
  //      RawEvent[scp+28] ---> BHA
  //      RawEvent[scp+29] ---> Presc BHA
  //      RawEvent[scp+30] ---> Presc BTB-EL
  //      RawEvent[scp+31] ---> OR-TOFONE
  //      RawEvent[scp+32] ---> Presc OR-MB
  //      RawEvent[scp+33] ---> Total Triggers
  //      RawEvent[scp+34] ---> TIME (100 Hz)
  //
  //      RawEvent[scp+35] ---> scaler V3 config (cascading)
  //      RawEvent[scp+36] ---> HYP
  //      RawEvent[scp+37] ---> BHA
  //      RawEvent[scp+38] ---> Presc OR-EL
  //      RawEvent[scp+39] ---> BTB-EL
  //      RawEvent[scp+40] ---> OR TOFONE
  //      RawEvent[scp+41] ---> LASER photodiode
  //      RawEvent[scp+42] ---> OR TOFINO
  //      RawEvent[scp+43] ---> SC (Slow Coincidence)
  //      RawEvent[scp+44] ---> void
  //      RawEvent[scp+45] ---> ORTofino*ORTofone
  //      RawEvent[scp+46] ---> void
  //      RawEvent[scp+47] ---> void
  //      RawEvent[scp+48] --->      |canali
  //      RawEvent[scp+49] ---> RF/4 |in cascata
  //      RawEvent[scp+50] ---> trigger*busy
  //      RawEvent[scp+51] ---> TIME (100 Hz)
  //
  //      RawEvent[scp+52] ---> scaler V4 config (cascading)
  //      RawEvent[scp+53] ---> HYP
  //      RawEvent[scp+54] ---> BHA
  //      RawEvent[scp+55] ---> Presc OR-EL
  //      RawEvent[scp+56] ---> BTB-EL
  //      RawEvent[scp+57] ---> OR TOFONE
  //      RawEvent[scp+58] ---> LASER photodiode
  //      RawEvent[scp+59] ---> OR TOFINO
  //      RawEvent[scp+60] ---> SC (Slow Coincidence)
  //      RawEvent[scp+61] ---> void
  //      RawEvent[scp+62] ---> ORTofino*ORTofone
  //      RawEvent[scp+63] ---> void
  //      RawEvent[scp+64] ---> void
  //      RawEvent[scp+65] --->      |canali
  //      RawEvent[scp+66] ---> RF/4 |in cascata
  //      RawEvent[scp+67] ---> trigger*busy
  //      RawEvent[scp+68] ---> TIME (100 Hz)
  //
  //      RawEvent[scp+69] ---> Scaler TOFINO config (cascading)
  //      RawEvent[scp+70] ---> Tofino MT 1
  //      RawEvent[scp+71] ---> Tofino MT 2
  //      RawEvent[scp+72] ---> Tofino MT 3
  //      RawEvent[scp+73] ---> Tofino MT 4
  //      RawEvent[scp+74] ---> Tofino MT 5
  //      RawEvent[scp+75] ---> Tofino MT 6
  //      RawEvent[scp+76] ---> Tofino MT 7
  //      RawEvent[scp+77] ---> Tofino MT 8
  //      RawEvent[scp+78] ---> Tofino MT 9
  //      RawEvent[scp+79] ---> Tofino MT 10
  //      RawEvent[scp+80] ---> Tofino MT 11
  //      RawEvent[scp+81] ---> Tofino MT 12
  //
  // --------------------------------------------------------------------------------
  // --------------------------------------------------------------------------------
  // --------------------------------------------------------------------------------
  //
  //  Description:
  //
  // --------------------------------------------------------------------------------
  //   - Structure (standard C library <time.h>) used for time management 
  //Begin_Html
  //   (see <a href="http://www.cplusplus.com/ref/ctime/tm.html">http://www.cplusplus.com/ref/ctime/tm.html</a>)
  //End_Html
  //     
  //
  //       typedef struct {
  //                       int tm_hour;   /* hour (0 - 23) */
  //                       int tm_isdst;  /* daylight saving time enabled/disabled */
  //                       int tm_mday;   /* day of month (1 - 31) */
  //                       int tm_min;    /* minutes (0 - 59) */
  //                       int tm_mon;    /* month (0 - 11 : 0 = January) */
  //                       int tm_sec;    /* seconds (0 - 59) */
  //                       int tm_wday;   /* Day of week (0 - 6 : 0 = Sunday) */
  //                       int tm_yday;   /* Day of year (0 - 365) */
  //                       int tm_year;   /* Year less 1900 */
  //                      } tm
  // --------------------------------------------------------------------------------
  //
  
  if(fDebugLev > 0) cout << "TFndPrean: reading scalers: online flag is " << fIsOnline << endl;
  
  if(!RawEvent){
    Error("ReadScalers","Pointer to the raw event is null! skipping");
    return;
  }

  fScalEvNum = RawEvent[2];
  
  TDatime check_evt_time;
  check_evt_time.Set(RawEvent[5]+RawEvent[6]);
  //  if ( RawEvent[2] % 10 ==0 ) cout << "ReadScalers: getting event: " << RawEvent[2] << " (" << check_evt_time.AsString() << ")"<< endl;
  // Now data are stored for rate calculations
  UInt_t scp = RawEvent[26] + k_EvHeaderLen;   //scaler pointer
  
  // --- old "running/stopped/crashed" management
  // #ifdef FndPrean_CheckForDaqRunning
  //   fScal0[5+13] = RawEvent[15];
  // #else
  //   fScal0[5+13] = K_DAQ_NotMonitored;
  // #endif
  
  for (UInt_t i=0; i< (Int_t)(E_FndScal_01_Desc_End) ; i++) fScal0[i] = RawEvent[scp+  i + 2];
  for (UInt_t i=0; i< (Int_t)(E_FndScal_01_Desc_End) ; i++) fScal1[i] = RawEvent[scp+  i + 19];

  for (UInt_t i=0; i< (Int_t)(E_FndScal_23_Desc_End) ; i++) fScal2[i] = RawEvent[scp+  i + 36];
  for (UInt_t i=0; i< (Int_t)(E_FndScal_23_Desc_End) ; i++) fScal3[i] = RawEvent[scp+  i + 53];

  for (UInt_t i=0; i< (Int_t)(E_FndScal_4_Desc_End) ; i++)  fScal4[i] = RawEvent[scp+  i + 70];
  
  // --- following lines can be uncommented for debugging purposes
  //   PrintScaler(0);  
  //   PrintScaler(1);  
  //   PrintScaler(2);  
  //   PrintScaler(3);  
  //   PrintScaler(4);  
  // ---
  
  // --- Set scaler data-members (for tree) [fScalEvNum already set]
  fScal_Time[E_Scal_Inhib_No ] = fScal2[E_FndScal_23_Desc_Time];
  fScal_Time[E_Scal_Inhib_Inj] = fScal0[E_FndScal_01_Desc_Time];
  fScal_Time[E_Scal_Inhib_All] = fScal1[E_FndScal_01_Desc_Time];
  
  fScal_HYP[E_Scal_Inhib_No ] = fScal2[E_FndScal_23_Desc_HYP];
  fScal_HYP[E_Scal_Inhib_Inj] = fScal0[E_FndScal_01_Desc_HYP];
  fScal_HYP[E_Scal_Inhib_All] = fScal1[E_FndScal_01_Desc_HYP];
  
  fScal_BHA[E_Scal_Inhib_No ] = fScal2[E_FndScal_23_Desc_BHA];
  fScal_BHA[E_Scal_Inhib_Inj] = fScal0[E_FndScal_01_Desc_BHA];
  fScal_BHA[E_Scal_Inhib_All] = fScal1[E_FndScal_01_Desc_BHA];
  
  fScal_ORtofino_MB[E_Scal_Inhib_No ] = fScal2[E_FndScal_23_Desc_OR_TOFI];
  fScal_ORtofino_MB[E_Scal_Inhib_Inj] = fScal0[E_FndScal_01_Desc_OR_MB];
  fScal_ORtofino_MB[E_Scal_Inhib_All] = fScal1[E_FndScal_01_Desc_OR_MB];
  
  fScal_ORtofone[E_Scal_Inhib_No ] = fScal2[E_FndScal_23_Desc_OR_TOFO];
  fScal_ORtofone[E_Scal_Inhib_Inj] = fScal0[E_FndScal_01_Desc_OR_TOFO];
  fScal_ORtofone[E_Scal_Inhib_All] = fScal1[E_FndScal_01_Desc_OR_TOFO];
  
  // ---
  fScalTree->Fill(); 

  return;
  
  // but it containg the rate evaluation, so I'm keeping it
  // as a reference (D. Faso)


  //  Float_t Tempo = ( (Float_t)(fScal1[17] - fScal0[17]) ) / 100.; // time interval (expressed in seconds)
  
  //   fDatime.Set(); // needed to evaluate the necessity of updating
  //   fConvTime = fDatime.Convert();
  
  //   if(fDebugLev > -1){  // new day - close old file and open new one
  //     cout << "*********************" << endl;
  //     cout << "ROOT  time: "  << fConvTime << endl;
  //     cout << " --- --- --- --- ---" << endl;
  //     cout << "ROOT  Day: "  << (UInt_t) ( ((Float_t) fConvTime) / kSecondsPerDay) << endl;
  //     cout << " --- --- --- --- ---" << endl;
  //     cout << "ROOT  Fif: "  << (UInt_t) ( ((Float_t) fConvTime) / kLuminInterval) << endl;
  //     cout << "*********************" << endl;
  //     // ---
  //     cout << "*********************" << endl;
  //     cout << "ROOT year  = " << fDatime.GetYear()  << endl;
  //     cout << "ROOT month = " << fDatime.GetMonth()  << endl;
  //     cout << "ROOT day   = " << fDatime.GetDay()  << endl;
  //     cout << "*********************" << endl;
  //   }
  
  //   if( (UInt_t) ( (((Float_t) fConvTime) / kSecondsPerDay) ) > fCurDay ) { 
  //     fCurDay = (UInt_t)( ((Float_t) fConvTime) / kSecondsPerDay ) ;
  
  
  //   }
  
  
  // file for DAFNE  
  //  for (Int_t i=2; i<18; i++)  fScalR[i] = ((Float_t)(fScal1[i]-fScal0[i])) / Tempo;
  //  for (Int_t i=19; i<35; i++) fScalR[i] = ((Float_t)(fScal1[i]-fScal0[i])) / Tempo;
  //   for (Int_t i=36; i<52; i++)
  //     if ((i!=44) && (i!=46) && (i!=47) && (i!=48) && (i!=49))
  //       fScalR[i] = ((Float_t)(fScal1[i]-fScal0[i]))/Tempo;
  //     else
  //       if (i==49)
  //    fScalR[i] = ((Float_t) ( ((fScal1[49]+(fScal1[48]*2^32))-(fScal0[49]+(fScal0[48]*2^32))) )) / Tempo;
  //   for (Int_t i=53; i<69; i++)
  //     if ((i!=61) && (i!=63) && (i!=64) && (i!=65) && (i!=66))
  //       fScalR[i] = ((Float_t) (fScal1[i]-fScal0[i]) ) / Tempo;
  //     else
  //       if (i==66)
  //    fScalR[i] = ((Float_t) ((fScal1[66]+(fScal1[65]*2^32))-(fScal0[66]+(fScal0[65]*2^32))) ) / Tempo;
  //   for (Int_t i=70; i < K_VmeScalBufLen; i++)
  //     fScalR[i] = ((Float_t) (fScal1[i]-fScal0[i]) ) / Tempo;
  
  //  fBhaCount1[E_count_trigger] += fScal1[11]-fScal0[11];
  
  // File for DAFNE
  //   if ( ( (UInt_t) (((Float_t)fConvTime) / kLuminInterval )) > fLastUpdTimeInt) { 
  //     //  if ( ( ((UInt_t)fConvTime) / kLuminInterval ) > fLastUpdTimeInt) { 
  //     //    if(fDebugLev > -1) cout << "====================== > for dafne 1" << endl; 
  //     fLastUpdTimeInt = (UInt_t) ( ((Float_t) fConvTime) / kLuminInterval );
  //     fBhaCount0[E_count_trigger] = fBhaCount1[E_count_trigger];
  //     fBhaCount1[E_count_trigger]=0;
  //   }
  
  // --- scalers fast
  //   cout << fConvTime << " " << RawEvent[1] << " " << RawEvent[2] 
  //             << " " << RawEvent[3] << " " << RawEvent[4] 
  //             << " " << fScal1[4] << " " << fScal1[5] << " " << fScal1[8] << " "  << fScal1[9] 
  //             << " " << fScal1[11] << " " << fScal1[14] << " " << fScal1[16] << " " << fScal1[17] 
  //             << " " << fScal1[70] << " " << fScal1[71] << " " << fScal1[72] << " " << fScal1[73]
  //             << " " << fScal1[74] << " " << fScal1[75] << " " << fScal1[76] << " " << fScal1[77]
  //             << " " << fScal1[78] << " " << fScal1[79] << " " << fScal1[80] << " " << fScal1[81]
  //             << " " << fScal1[5+13] << " " << fBhaCount0[E_count_trigger] << " " << endl;
  
  
  /*
    
  #ifdef FndPrean_CheckForDaqRunning
  Bool_t MustWrite = RawEvent[15] == K_DAQ_Active;
  #else
  Bool_t MustWrite = kFALSE;
  #endif
  
  
  if( !( fConvTime % kLuminInterval) && (fConvTime != fCurTime) || MustWrite) {
  //  if( !( fConvTime % kLuminInterval) && (fConvTime != fCurTime) ) {
  
  // RawEvent[15] meaningful in online mode only: see FROOT.h
  // in raw data RawEvent[15] always set to zero
  
  if(fDebugLev > 1) cout << " ======> CurTime:"<< fCurTime << " ======> fConvTime:"<< fConvTime  << " ======> RawEvent[15]:"<< RawEvent[15] << endl;    
  fCurTime = fConvTime;
  
  // File for DAFNE
  //     cout << fConvTime << " " << RawEvent[1] << " " << RawEvent[2] 
  //              << " " << RawEvent[3] << " " << RawEvent[4] 
  //              << " " << fScal1[4] << " " << fScal1[5] << " " << fScal1[8] << " "  << fScal1[9] 
  //              << " " << fScal1[11] << " " << fScal1[14] << " " << fScal1[16] << " " << fScal1[17] 
  //              << " " << fScal1[70] << " " << fScal1[71] << " " << fScal1[72] << " " << fScal1[73]
  //              << " " << fScal1[74] << " " << fScal1[75] << " " << fScal1[76] << " " << fScal1[77]
  //              << " " << fScal1[78] << " " << fScal1[79] << " " << fScal1[80] << " " << fScal1[81]
  //              << " " << fScal1[5+13] << " " << fBhaCount0[E_count_trigger] << " " << endl;
  
  }
  */  
  
  
  //   for (Int_t ii=0; ii < K_VmeScalBufLen; ii++){
  //     fScal0[ii] = fScal1[ii];
  //   }
  //  if ( RawEvent[2] % 10 ==0 ) cout << "ReadScalers: last processed event: " << RawEvent[2] << endl;
  
}

//_____________________________
void TFndPrean::PrintScaler(Int_t scal_id){
  // scal_id = 0,1,2,3,4
  
  cout << " ----- ----- ----- ----- ----- -----" << endl;
  cout << "   Printing content of scaler " << scal_id << " ( event " << fScalEvNum << ")" << endl;
  
  if(scal_id == 0 || scal_id ==1){
    if(scal_id == 0){
      cout << "  (injection inhibit)" << endl;
      for(Int_t bit=0; bit< E_FndScal_01_Desc_End; bit++)
        cout << GetScal_01_DescName(bit).Data() << " : " <<  fScal0[bit] << endl;
    }
    else{
      cout << "  (inhibit)" << endl;
      for(Int_t bit=0; bit< E_FndScal_01_Desc_End; bit++)
        cout << GetScal_01_DescName(bit).Data() << " : " <<  fScal1[bit] << endl;
    }
  }
  //
  else if(scal_id == 2 || scal_id ==3){
    if(scal_id == 2){
      cout << "  (no inhibit)" << endl;
      for(Int_t bit=0; bit< E_FndScal_23_Desc_End; bit++)
        cout << GetScal_23_DescName(bit).Data() << " : " <<  fScal2[bit] << endl;
    } 
    else{
      cout << "  (inhibit)" << endl;
      for(Int_t bit=0; bit< E_FndScal_23_Desc_End; bit++)
        cout << GetScal_23_DescName(bit).Data() << " : " <<  fScal3[bit] << endl;
    } 
    
  }
  //
  else if(scal_id == 4){
    cout << "  (TOFINO RATES)" << endl;
    for(Int_t bit=0; bit< E_FndScal_4_Desc_End; bit++)
      cout << GetScal_4_DescName(bit).Data() << " : " <<  fScal4[bit] << endl;
  } 
  
  cout << " ----- ----- ----- ----- ----- -----" << endl;
  
}


//_____________________________
void TFndPrean::AnalyzeBhabha(TFndProcessRec *prec){
  // look at fidarc ===> FILLCRBHA1

  Int_t JFDST = prec->GetJFDST();
  if(!JFDST){
    if(fCurLogFile) *fCurLogFile << "AnalyzeBhabha Warning: JFDST=0" << endl;
    // Warning("AnalyzeBhabha","JFDST=0");
    return;
  }
  fBhaEvNum = prec->GetIQ(JFDST+2); // event written  in zebra DST
  //  Int_t curev = prec->GetIQ(JFDST+2); // event written  in zebra DST
  Int_t ev_time = prec->GetIQ(JFDST+5);
  Int_t TrigBit = prec->GetIQ(JFDST+3);

  //  cout << "=============> " << TrigBit << endl;
  
  // Trigger bit 11 is omitted for now
  //   if(TrigBit == 2 || TrigBit == 11){
  if(TrigBit != 2) return;
  
  Int_t LBHA=prec->GetLQ(JFDST-1);
  if(!LBHA) return;
  
  // --- it could seem strange, but the
  //     pattern-recognition error code
  //     lies inside the noise bank.
  Int_t L_NOISE = prec->GetLQ( JFDST - 2);
  if(!L_NOISE){
    if(fCurLogFile) *fCurLogFile << "AnalyzeBhabha Warning: Noise bank empty (ev " << fBhaEvNum << ")" << endl;
    //    Warning("AnalyzeBhabha","Noise bank empty (pattern-recognition error code unknown)");
    return;
  }
  if(prec->GetIQ(L_NOISE+1) != 0) return; // pattern recognition error
  
  // --- info from bhabha bank
  //  
  fBhaVertImpossible = (Bool_t)( prec->GetStatusBit(LBHA,1) );
  fBhaVertDoubtful = (Bool_t)( prec->GetStatusBit(LBHA,2) );
  

  if(fBhaVertImpossible == kFALSE){ // inverted logic according to zebra content
    //    cout << "fBhaVertImpossible: " << fBhaVertImpossible << "; fBhaVertDoubtful: "  << fBhaVertDoubtful << endl;
    for(Int_t axis=1;axis<=3;axis++){
      //cout << "axis " << axis << ": " << prec->GetQ(LBHA + axis) << " ; " ;
      fBhaVertPos[axis-1] = prec->GetQ(LBHA + axis);
    }
    //    cout << endl << endl;
  }


  // No selection (at this level) on vertex determination possibility:
  // single tracks will be inspected anyway
  
  Int_t L_PART = 0; // address of the zebra bank for current particle (e- / e+)
  for(Int_t p_i = 0; p_i <= 1; p_i++ ){
    // p_i = 1 -> electron (or negative pion from K_short)
    // p_i = 2 -> positron (or positive pion from K_short)
    L_PART = prec->GetLQ( LBHA - (p_i + 1) );
    
    while(L_PART){
      if(prec->GetIQ(L_PART+1) != fForeseenSign[p_i]){
        if(fCurLogFile) *fCurLogFile << "unexpected sign (ev " << fBhaEvNum << "; p_i = " << p_i << ")" << endl;
        //      Warning("AnalyzeBhabha","unexpected sign for reconstructed track (p_i = %d)",p_i);
        L_PART= prec->GetLQ(L_PART);
        continue;
      }
      
      // --- fill variables
      fBhaIsLong[p_i] = (Bool_t)( prec->GetStatusBit(L_PART,1) );
      fBhaMom[p_i] = prec->GetQ(L_PART+11);
      
      fBhaPipe_X[p_i] = prec->GetQ(L_PART+30);
      fBhaPipe_Y[p_i] = prec->GetQ(L_PART+31);
      fBhaPipe_Z[p_i] = prec->GetQ(L_PART+32);

      fBhaDirCos_X[p_i] = prec->GetQ(L_PART+33);
      fBhaDirCos_Y[p_i] = prec->GetQ(L_PART+34);
      fBhaDirCos_Z[p_i] = prec->GetQ(L_PART+35);
      
      fBhaPipeAngle[p_i] = prec->GetQ(L_PART+38);
      fBhaPipeAngle[p_i] = fBhaPipeAngle[p_i] * TMath::RadToDeg(); // conversion to degrees
      
      // --- Inspect TOF hits in order to grab time info ( set "fBhaTofiTime" and "fBhaTofoTime")
      Int_t L_BHA_TOFI = prec->GetLQ(L_PART - 1);
      Int_t L_BHA_TOFO = prec->GetLQ(L_PART - 7);
      if(L_BHA_TOFI !=0 && L_BHA_TOFO !=0){
        fBhaTofiTime[p_i] = prec->GetQ(L_BHA_TOFI + 14);
        fBhaTofoTime[p_i] = prec->GetQ(L_BHA_TOFO + 14);
      }
      // --- information needed by event-display for displaying tracks
      fBhaGeoPRradius[p_i] = prec->GetQ(L_PART + 4);
      //
      fBhaGeoFitPoint_X[p_i] = prec->GetQ(L_PART + 13);
      fBhaGeoFitPoint_Y[p_i] = prec->GetQ(L_PART + 14);
      fBhaGeoFitPoint_Z[p_i] = prec->GetQ(L_PART + 15);
      //
      fBhaGeoFitDirCos_X[p_i] = prec->GetQ(L_PART + 16);
      fBhaGeoFitDirCos_Y[p_i] = prec->GetQ(L_PART + 17);
      fBhaGeoFitDirCos_Z[p_i] = prec->GetQ(L_PART + 18);

      fBhaTrackLength[p_i] = prec->GetQ(L_PART + 29);
      // --- now just check if there is more than one track with the same sign
      L_PART= prec->GetLQ(L_PART);
      if(L_PART !=0){ 
        if(fCurLogFile) *fCurLogFile << "More than one track with the same sign (ev " << fBhaEvNum << "; p_i = " << p_i << ")" << endl;
        break; // any unexpected track is not considered
      }
    }
  }

  //--- Now calculations on track attributes will follow
  
  // total momentum and angle between tracks
  if(fBhaVertImpossible == kFALSE){ // inverted logic according to zebra content
    Double_t mom_tot = 0; // need a double to use the "ScalarProduct" method
    Double_t ang_trks = 0; // need a double to use the "ScalarProduct" method
    
    Double_t scal_mom = 0; // module of the scalar product
    ScalarProduct(fBhaMom[FPh_BhaElec_id],
                  fBhaDirCos_X[FPh_BhaElec_id],
                  fBhaDirCos_Y[FPh_BhaElec_id],
                  fBhaDirCos_Z[FPh_BhaElec_id],
                  fBhaMom[FPh_BhaPosit_id],
                  fBhaDirCos_X[FPh_BhaPosit_id],
                  fBhaDirCos_Y[FPh_BhaPosit_id],
                  fBhaDirCos_Z[FPh_BhaPosit_id],
                  scal_mom,
                  ang_trks
                  );
    
    Double_t cdx_res = 0;
    Double_t cdy_res = 0;
    Double_t cdz_res = 0;
    mom_tot = FIN_PHYS::Sum(fBhaMom[FPh_BhaElec_id],
                            fBhaDirCos_X[FPh_BhaElec_id],
                            fBhaDirCos_Y[FPh_BhaElec_id],
                            fBhaDirCos_Z[FPh_BhaElec_id],
                            fBhaMom[FPh_BhaPosit_id],
                            fBhaDirCos_X[FPh_BhaPosit_id],
                            fBhaDirCos_Y[FPh_BhaPosit_id],
                            fBhaDirCos_Z[FPh_BhaPosit_id],
                            cdx_res,cdy_res,cdz_res);    
    
    
    fBhaTotalMomentum = (Float_t) mom_tot;
    
    if(ang_trks != -999) fBhaAngle = (Float_t) (ang_trks * TMath::RadToDeg());
    else fBhaAngle = ang_trks;
    
    // invariant masses (different hypothesis)
    fBhaInvMass_EpluEmin =  CenterMassEnergy(FPh_PID_Electron,
                                             fBhaMom[FPh_BhaElec_id],
                                             fBhaDirCos_X[FPh_BhaElec_id],
                                             fBhaDirCos_Y[FPh_BhaElec_id],
                                             fBhaDirCos_Z[FPh_BhaElec_id],
                                             FPh_PID_Positron,
                                             fBhaMom[FPh_BhaPosit_id],
                                             fBhaDirCos_X[FPh_BhaPosit_id],
                                             fBhaDirCos_Y[FPh_BhaPosit_id],
                                             fBhaDirCos_Z[FPh_BhaPosit_id]);
    
    //  cout << " ===> ee: " << fBhaInvMass_EpluEmin << endl;
    
    
    fBhaInvMass_PIpluPImin =  CenterMassEnergy(FPh_PID_Pi_min,
                                               fBhaMom[FPh_BhaElec_id],
                                               fBhaDirCos_X[FPh_BhaElec_id],
                                               fBhaDirCos_Y[FPh_BhaElec_id],
                                               fBhaDirCos_Z[FPh_BhaElec_id],
                                               FPh_PID_Pi_plu,
                                               fBhaMom[FPh_BhaPosit_id],
                                               fBhaDirCos_X[FPh_BhaPosit_id],
                                               fBhaDirCos_Y[FPh_BhaPosit_id],
                                               fBhaDirCos_Z[FPh_BhaPosit_id]);
    
    
  }
  // ---
  fBhabhaTree->Fill(); 
}

//_____________________________
void TFndPrean::AnalyzeHype(TFndProcessRec *prec){
  // notes for further developments (Aug 29, 2007 - D. Faso):
  //
  //  - K vertex check (tracks crossing point inside target)
  //    should be added while evaluating stopped K-/K+
  //      [ see fidarc->ktrkvert   Q(LLAST+57) = DIFFZ ]
  //
  //  - Up to now long tracks only are considered:
  //    short tracks could be considered.
  //    ( it will not be possible to distinguish   )
  //    ( different types of short tracks:         )
  //    ( for example we could consider all fitted )
  //    ( tracks with three or more points.        )

  Int_t JFDST = prec->GetJFDST();
  if(!JFDST){
    if(fCurLogFile) *fCurLogFile << "AnalyzeHype warning: JFDST=0" << endl;
    //    Warning("AnalyzeHype","JFDST=0");
    return;
  }
  fHypEvNum = prec->GetIQ(JFDST+2); // event written  in zebra DST
  //  Int_t curev = prec->GetIQ(JFDST+2); // event written  in zebra DST
  Int_t ev_time = prec->GetIQ(JFDST+5);
  Int_t TrigBit = prec->GetIQ(JFDST+3);
  
  //  cout << "=============> Current event: " << fHypEvNum << endl; // DEBUGGING
  //  cout << "=============> " << TrigBit << endl;
  
  // this check will always start with trigger bit == 11 will
  //   if(TrigBit == 2 || TrigBit == 11){
  if(TrigBit != 1 && TrigBit != 11 ) return;
  

  //  fHyp_PattRec_Err///////////////////////////////////
  Int_t L_NOISE = prec->GetLQ( JFDST - 3);
  if(!L_NOISE){
    if(fCurLogFile) *fCurLogFile << "AnalyzeHype Warning: Noise bank empty (ev " << fHypEvNum << ")" << endl;
    return;
  }
  fHyp_PattRec_Err = prec->GetIQ(L_NOISE+1); // pattern recognition error-code
  
  Int_t L_KAON=0;
  for(Int_t p_i = 0; p_i <= 1; p_i++ ){
    // p_i = 0 -> K-
    // p_i = 1 -> K+
    L_KAON = prec->GetLQ(JFDST - (p_i + 1) );
    
    while(L_KAON){

      // --- phi decay position
      Bool_t same_point = kTRUE;
      if(p_i== 1){ // check if K- and K+ gives the same point for Phi decay
        for(Int_t chk=0;chk<3;chk++){
          if( prec->GetQ(L_KAON + 12+chk) != fHyp_PhiDecayPos[chk]){
            same_point = kFALSE;
            break;
          }
        }
      }
      if(!same_point){
        if(fCurLogFile) *fCurLogFile << "AnalyzeHype warning: Phy decay position different from K- to K+ (ev " << fHypEvNum << ")" << endl;
        //Warning("AnalyzeHype","Phy decay position different from K- to K+ (ev %d)",fHypEvNum);
        L_KAON= prec->GetLQ(L_KAON);
        continue;
      }
      for(Int_t axis=0;axis<3;axis++) fHyp_PhiDecayPos[axis] = prec->GetQ(L_KAON + 12 + axis);
      // --- phi decay position completed


      // --- kaon stopping point      
      //--- stop volume check as in FILLGENHYP (fidarc)
      TString Vnam = HolleritToString(prec->GetIQ(L_KAON + 1));
      
      fHypStopID[p_i] = (Int_t)E_Kaon_Stop_Other;
      if(! Vnam.CompareTo("ISIM")) fHypStopID[p_i] = (Int_t) E_Kaon_Stop_Isim;
      else if(! Vnam.CompareTo("IGLA")) fHypStopID[p_i] = (Int_t)E_Kaon_Stop_Glass;
      else if(! Vnam.CompareTo("IUPL")) fHypStopID[p_i] = (Int_t)E_Kaon_Stop_Upilex;
      else if(! Vnam.CompareTo("OSIM")) fHypStopID[p_i] = (Int_t) E_Kaon_Stop_Osim;
      else{
        Vnam.Resize(3);
        if(! Vnam.CompareTo("TAR")) fHypStopID[p_i] = (Int_t)E_Kaon_Stop_Target;
      }
      
      //       cout << "Vnam:        \"" << Vnam << "\"." << endl;
      //       cout << "fHypStopID: \"" << fHypStopID[p_i] << "\"." << endl << endl;

      if( fHypStopID[p_i] == (E_Kaon_StopCode)E_Kaon_Stop_Target ||
          fHypStopID[p_i] == (E_Kaon_StopCode)E_Kaon_Stop_Isim )
        {
          fHypStopTgtNum[p_i] = prec->GetIQ(L_KAON + 2);
          fHypStopVolNum[p_i] = -1;
        }
      else{
        fHypStopTgtNum[p_i] = -1; 
        fHypStopVolNum[p_i] = prec->GetIQ(L_KAON + 2);
      }

      // ---
      fHyp_K_StopPoint_X[p_i] = prec->GetQ(L_KAON + 5);
      fHyp_K_StopPoint_Y[p_i] = prec->GetQ(L_KAON + 6);
      fHyp_K_StopPoint_Z[p_i] = prec->GetQ(L_KAON + 7);
      // --- kaon stopping point completed
      
      Int_t L_K_ISIM = prec->GetLQ(L_KAON - 2);
      if(L_K_ISIM) fHyp_K_DeDx_Isi[p_i] = prec->GetQ(L_K_ISIM + 11);
      
      
      // single particle (K-/K+) examined (tracks can follow)
      // --- tracks inspection (to be implemented)
      Int_t L_TRACK=0;
      Int_t id_trk = 0; // [0,1,2]: [neg,pos,neut]
      TFndTrack *CurTrack = 0;


      // --- load start time for every track
      Int_t L_K_ISLB = prec->GetLQ(L_KAON - 1);
      Float_t start_time = 0;
      if(L_K_ISLB) start_time = prec->GetQ(L_K_ISLB + 14); // Slab Time, average of Left & Right TDCs (ns)
      // ---

      for(id_trk = 0; id_trk<3; id_trk++){
        if(p_i == 1 && id_trk == 2) break; // neutral-tracks is void in zebra for K+

        if(fDebugLev>1){ // DEBUGGING
          cout << endl << " ...inspecting track-id \"" << id_trk 
               << "\"   (part-id: " << p_i 
               << "; ev " << fHypEvNum << ")." << endl;
        }

        Int_t trk_count = 0;
        L_TRACK = prec->GetLQ(L_KAON - 3 -id_trk );
        //      Printf("LTRACK = %d",L_TRACK);
        
        while(L_TRACK){
          trk_count++;
          AddTrack(p_i);
          // single track decoding (fCurTrack is used)

          if(id_trk == 0 || id_trk == 1){ // charged particles
            fCurTrack->fCharge = ( id_trk == 0 ) ? -1 : +1;
            // now check fit charge result
            if(prec->GetIQ(L_TRACK + 7) == TFndTrack::E_Trk_Fit_Success){
              Bool_t is_pos = (Bool_t)( prec->GetStatusBit(L_TRACK,7) );
              if(id_trk == 0 && is_pos || id_trk == 1 && !is_pos ) {
                fCurTrack->fChargeAmbig = kTRUE;
                //              cout <<" Unexpected charge for rec. trk (ev. " << fHypEvNum  << " ; id: " << id_trk << " ; is_pos: " << is_pos << ")" << endl;
                //
                if(fCurLogFile) *fCurLogFile << " Unexpected sign for rec. trk (ev. " << fHypEvNum
                                             << " ; id: " << id_trk << " ; is_pos: " << is_pos << ")" << endl;
              }
              else fCurTrack->fChargeAmbig = kFALSE; // safe but not mandatory
            }
            
#ifndef FIDA_USE_SHORT
            fCurTrack->fFwd = (Bool_t)( prec->GetStatusBit(L_TRACK,2) );
#endif
            // --- from pattern recognition
            fCurTrack->fPR_Helix[TFndTrack::E_Hel_Xc] = prec->GetQ(L_TRACK + 1);
            fCurTrack->fPR_Helix[TFndTrack::E_Hel_Yc] = prec->GetQ(L_TRACK + 2);
            fCurTrack->fPR_Helix[TFndTrack::E_Hel_R] = prec->GetQ(L_TRACK + 3);
#ifdef FIDA_USE_SHORT
            fCurTrack->fPR_MomVert[TFndTrack::E_Hel_Mom] = prec->GetQ(L_TRACK + 8);
            fCurTrack->fPR_MomVert[TFndTrack::E_Hel_Lam] = prec->GetQ(L_TRACK + 9);
            fCurTrack->fPR_MomVert[TFndTrack::E_Hel_Phi] = prec->GetQ(L_TRACK + 10);
#else
            // following lines shall be considered deprecated
            cout << "ARE YOU SURE YOU DON'T WANT TO USE SHORT_TRACK PROCEDURE?" << endl;
            fCurTrack->fPR_MomVert[TFndTrack::E_Hel_Mom] = prec->GetQ(L_TRACK + 4);
            fCurTrack->fPR_MomVert[TFndTrack::E_Hel_Lam] = prec->GetQ(L_TRACK + 5);
            fCurTrack->fPR_MomVert[TFndTrack::E_Hel_Phi] = prec->GetQ(L_TRACK + 6);
#endif
            
            // --- from fit
            fCurTrack->fStart[TFndTrack::E_Trk_X] = prec->GetQ(L_TRACK + 14);
            fCurTrack->fStart[TFndTrack::E_Trk_Y] = prec->GetQ(L_TRACK + 15);
            fCurTrack->fStart[TFndTrack::E_Trk_Z] = prec->GetQ(L_TRACK + 16);
            fCurTrack->fStart[TFndTrack::E_Trk_cosX] = prec->GetQ(L_TRACK + 17);
            fCurTrack->fStart[TFndTrack::E_Trk_cosY] = prec->GetQ(L_TRACK + 18);
            fCurTrack->fStart[TFndTrack::E_Trk_cosZ] = prec->GetQ(L_TRACK + 19);

            fCurTrack->fStop[TFndTrack::E_Trk_X] = prec->GetQ(L_TRACK + 20);
            fCurTrack->fStop[TFndTrack::E_Trk_Y] = prec->GetQ(L_TRACK + 21);
            fCurTrack->fStop[TFndTrack::E_Trk_Z] = prec->GetQ(L_TRACK + 22);
            fCurTrack->fStop[TFndTrack::E_Trk_cosX] = prec->GetQ(L_TRACK + 23);
            fCurTrack->fStop[TFndTrack::E_Trk_cosY] = prec->GetQ(L_TRACK + 24);
            fCurTrack->fStop[TFndTrack::E_Trk_cosZ] = prec->GetQ(L_TRACK + 25);

#ifndef FIDA_USE_SHORT
            cout << "ARE YOU SURE YOU DON'T WANT TO USE SHORT_TRACK PROCEDURE?" << endl;
            Bool_t is_long_track = (Bool_t)( prec->GetStatusBit(L_TRACK,1) );
            fCurTrack->fNumOfHits = (is_long_track) ? 4 : 3;
#endif
            fCurTrack->fFitErr = prec->GetIQ(L_TRACK + 7);
            fCurTrack->fLength = prec->GetQ(L_TRACK + 30);
            
            fCurTrack->fFit_MomVert[TFndTrack::E_Hel_Mom] = prec->GetQ(L_TRACK +  8);
            fCurTrack->fFit_MomVert[TFndTrack::E_Hel_Lam] = prec->GetQ(L_TRACK +  9);
            fCurTrack->fFit_MomVert[TFndTrack::E_Hel_Phi] = prec->GetQ(L_TRACK + 10);
            
            fCurTrack->fFit_MomVertErr[TFndTrack::E_Hel_Mom] = prec->GetQ(L_TRACK + 11);
            fCurTrack->fFit_MomVertErr[TFndTrack::E_Hel_Lam] = prec->GetQ(L_TRACK + 12);
            fCurTrack->fFit_MomVertErr[TFndTrack::E_Hel_Phi] = prec->GetQ(L_TRACK + 13);

            fCurTrack->fChiSq[TFndTrack::E_Trk_ChiSq_DEV] = prec->GetQ(L_TRACK + 26);
            fCurTrack->fChiSq[TFndTrack::E_Trk_ChiSq_RES] = prec->GetQ(L_TRACK + 27);
            fCurTrack->fChiSq[TFndTrack::E_Trk_ChiSq_LOSTstb] = prec->GetQ(L_TRACK + 28);
            fCurTrack->fChiSq[TFndTrack::E_Trk_ChiSq_STEREOstb] = prec->GetQ(L_TRACK + 29);
            
            // --- from backtracking
            fCurTrack->fExtrapolated = (Bool_t)( prec->GetStatusBit(L_TRACK,10) );
            fCurTrack->fBackTrack[TFndTrack::E_Trk_Bcktrk_NormAng]          = prec->GetQ(L_TRACK + 31);
            fCurTrack->fBackTrack[TFndTrack::E_Trk_Bcktrk_SurfApproach]     = prec->GetQ(L_TRACK + 32);
            fCurTrack->fBackTrack[TFndTrack::E_Trk_Bcktrk_MaxApproach]      = prec->GetQ(L_TRACK + 33);
            fCurTrack->fBackTrack[TFndTrack::E_Trk_Bcktrk_SurfPlanePath]    = prec->GetQ(L_TRACK + 34);
            fCurTrack->fBackTrack[TFndTrack::E_Trk_Bcktrk_ExtrDist]         = prec->GetQ(L_TRACK + 35);
            fCurTrack->fBackTrack[TFndTrack::E_Trk_Bcktrk_dPtgt_spline]     = prec->GetQ(L_TRACK + 36);
            fCurTrack->fBackTrack[TFndTrack::E_Trk_Bcktrk_dPtgt_spline_cor] = prec->GetQ(L_TRACK + 37);
            fCurTrack->fBackTrack[TFndTrack::E_Trk_Bcktrk_pid]              = (Float_t)( prec->GetIQ(L_TRACK + 38) );

            // ---
            // Evaluate PATH and ADD time info to "fStart" and "fStop"
            
            // only the first hit on every detector
            // is considered for the required pre-analysis
            //   (we need to set path and time)
            Int_t L_TRK_ISIM = 0;
            Int_t L_TRK_OSIM = 0;
            Int_t L_TRK_DCH1 = 0;
            Int_t L_TRK_DCH2 = 0;
            Int_t L_TRK_TRIT = 0;
            Int_t L_TRK_TOFO = 0;

            Int_t pth_tofi = 0; // will not change here (tofino not involved)
            Int_t pth_isim = 0; // will not change here (isim not involved)
            Int_t pth_osim = 0;
            Int_t pth_lmd_inn = 0;
            Int_t pth_lmd_out = 0;
            Int_t pth_tofo = 0;
            
            L_TRK_ISIM = prec->GetLQ(L_TRACK - 8);
            if(L_TRK_ISIM){
              fCurTrack->fDeDx[0] = prec->GetQ(L_TRK_ISIM + 11);
              pth_isim =  prec->GetIQ(L_TRK_ISIM + 1);
            }
            
            
            L_TRK_OSIM = prec->GetLQ(L_TRACK - 1 );
            if(L_TRK_OSIM){
              fCurTrack->fDeDx[1] = prec->GetQ(L_TRK_OSIM + 11);
              pth_osim = prec->GetIQ(L_TRK_OSIM + 1);
              //cout << "OSIM = " << pth_osim << endl;
            }
            
            L_TRK_DCH1 = prec->GetLQ(L_TRACK - 2);
            if(L_TRK_DCH1){
              pth_lmd_inn = prec->GetIQ(L_TRK_DCH1 + 1);
              //cout << "DCH1 = " << pth_lmd_inn << endl;
            }

            L_TRK_DCH2 = prec->GetLQ(L_TRACK - 4);
            if(L_TRK_DCH2){
              pth_lmd_out = prec->GetIQ(L_TRK_DCH2 + 1);
              //cout << "DCH2 = " << pth_lmd_out << endl;
            }

            // L_TRK_TRIT = prec->GetLQ(L_TRACK - 6); // not needed here

            L_TRK_TOFO = prec->GetLQ(L_TRACK - 7);
            if(L_TRK_TOFO){
              pth_tofo = prec->GetIQ(L_TRK_TOFO + 1);
              //cout << "TOFO = " << pth_tofo << endl;
            }


            fCurTrack->SetPath(pth_tofi, pth_isim, pth_osim, pth_lmd_inn, pth_lmd_out, pth_tofo);
            
            // TIME
            Float_t stop_time = 0;
            if(L_TRK_TOFO && start_time){
              stop_time = prec->GetQ(L_TRK_TOFO + 14); // Slab Time, average of Left & Right TDCs (ns)
              fCurTrack->fStart[TFndTrack::E_Trk_T] = start_time;
              fCurTrack-> fStop[TFndTrack::E_Trk_T] = stop_time;
              fCurTrack->fTOF = stop_time - start_time;
            }
            // ---
            //      L_TRACK + 39 , 40 ... 52
            // --- type (hit layers)
#ifdef FIDA_USE_SHORT
            Int_t n_isim = 0;
            Int_t n_osim = 0;
            Int_t n_lmd_inn = 0;
            Int_t n_lmd_out = 0;
            Int_t n_stb = 0;
            
            L_TRK_ISIM = prec->GetLQ(L_TRACK - 8); // not needed here
            if(L_TRK_ISIM) do{
              n_isim++;
              L_TRK_ISIM = prec->GetLQ(L_TRK_ISIM);                    
            } while(L_TRK_ISIM);
            if(n_isim > 9) n_isim = 9;
            //
            L_TRK_OSIM = prec->GetLQ(L_TRACK - 1 );
            if(L_TRK_OSIM != 0) n_osim = 10;
            //
            L_TRK_DCH1 = prec->GetLQ(L_TRACK - 2);
            if(L_TRK_DCH1 != 0) n_lmd_inn = 100;
            //
            L_TRK_DCH2 = prec->GetLQ(L_TRACK - 4);
            if(L_TRK_DCH2 != 0) n_lmd_out = 1000;
            //
            L_TRK_TRIT = prec->GetLQ(L_TRACK - 6);
            if(L_TRK_TRIT != 0) n_stb = 10000;
            fCurTrack->fType = n_isim + n_osim + n_lmd_inn + n_lmd_out + n_stb ;
            if(fDebugLev > 0) cout << "EVENT: " << fHypEvNum << endl;
            if(fDebugLev > 2) cout << "L_TRACK + 39 ===> " << prec->GetQ(L_TRACK + 39) << endl;
            fCurTrack->EvalTrack(); // forward value is also evaluated
            fCurTrack->fDistVert = prec->GetQ(L_TRACK + 39);
            //
            fCurTrack->fIsimCos = prec->GetQ(L_TRACK + 40);
            fCurTrack->fOsimCos = prec->GetQ(L_TRACK + 41);
            fCurTrack->fLmd1Cos = prec->GetQ(L_TRACK + 42);
            fCurTrack->fLmd2Cos = prec->GetQ(L_TRACK + 43);

            // --- SUPPORT for corrected dE/dx (considering track attack-angle)
            //
            L_TRK_ISIM = prec->GetLQ(L_TRACK - 8);
            if(L_TRK_ISIM && fCurTrack->fIsimCos){
              fCurTrack->fCorr_DeDx[0] =
                fCurTrack->fIsimCos * ( (prec->GetQ(L_TRK_ISIM+7) + prec->GetQ(L_TRK_ISIM+9)) / 2 );
            }
            L_TRK_OSIM = prec->GetLQ(L_TRACK - 1);
            if(L_TRK_OSIM && fCurTrack->fOsimCos){
              fCurTrack->fCorr_DeDx[1] =
                fCurTrack->fOsimCos * ( (prec->GetQ(L_TRK_OSIM+7) + prec->GetQ(L_TRK_OSIM+9)) / 2 );
            }
            L_TRK_DCH1 = prec->GetLQ(L_TRACK - 2);
            if(L_TRK_DCH1 && fCurTrack->fLmd1Cos){
              fCurTrack->fCorr_DeDx[2] =
                fCurTrack->fLmd1Cos * ( (prec->GetQ(L_TRK_DCH1+10) + prec->GetQ(L_TRK_DCH1+11)) / 2 );
            }
            L_TRK_DCH2 = prec->GetLQ(L_TRACK - 4);
            if(L_TRK_DCH2 && fCurTrack->fLmd2Cos){
              fCurTrack->fCorr_DeDx[3] =
                fCurTrack->fLmd2Cos * ( (prec->GetQ(L_TRK_DCH2+10) + prec->GetQ(L_TRK_DCH2+11)) / 2 );
            }
            //
            // ---
            // D. Faso: I'm stopping here ( Oct 2d, 2007 ):
            //  Vertex assignment procedure is not completed yet in fidarc.
            //
            // This section needs to be completed:
            //  TFndVertex class and vertices array are ready:
            //  Just fill them from zebra as soon as they will be available
            //  in fidarc.
#endif

          }
          else{ // neutral tracks
            fCurTrack->fCharge = 0;
            fCurTrack->fTOF = prec->GetQ(L_TRACK + 1);

            fCurTrack->fPR_MomVert[TFndTrack::E_Hel_Mom] = prec->GetQ(L_TRACK + 4);
            fCurTrack->fPR_MomVert[TFndTrack::E_Hel_Lam] = prec->GetQ(L_TRACK + 6);
            fCurTrack->fPR_MomVert[TFndTrack::E_Hel_Phi] = prec->GetQ(L_TRACK + 7);

            fCurTrack->fEnergy = prec->GetQ(L_TRACK + 5);
          }

          // ---
          if(fDebugLev>1) { // DEBUGGING print-out
            Printf("Event: %i; part_id: %i, trk_id: %i, trk num: %i",fHypEvNum, p_i, id_trk, trk_count);
            fCurTrack->PrintData(4);
          }
          // ---
          L_TRACK= prec->GetLQ(L_TRACK);
        }
        if(fDebugLev>0 && trk_count > 0) cout << "number of tracks = " << trk_count << endl << endl;
        // finishing sign (tracks)
      }
      // --- tracks inspection completed
      
      // --- GRAV info (geometric information about phi-vertex reconstruction)      
      Int_t L_K_GRAV = prec->GetLQ(L_KAON - 6);
      if(L_K_GRAV){
        fHyp_K_Vert_Center_X[p_i] = prec->GetQ(L_K_GRAV + 1);
        fHyp_K_Vert_Center_Y[p_i] = prec->GetQ(L_K_GRAV + 2);
        fHyp_K_Vert_Radius[p_i]   = prec->GetQ(L_K_GRAV + 3);
      }
      // ---
      L_KAON= prec->GetLQ(L_KAON);
      if(L_KAON !=0){ 
        if(fCurLogFile) *fCurLogFile << "More than one kaon with the same charge in zebra (p_i = " << p_i << ")" << endl;
        //      Warning("AnalyzeHype","More than one kaon with the same charge in zebra (p_i = %d)",p_i);
        // TerminateFroot();
      }
    } // single particle (K-/K+) completed
  } // K-/K+ loop completed
  
  // ---
  fHypeTree->Fill(); 
}

// --------------------
//--- check methods ---
// --------------------

//_____________________________
Int_t TFndPrean::CheckTofinoCFDs(TFndProcessRec *prec){
  // find CFD glitches:
  // This method MUST be called before processing the standard
  // fidarc event reconstruction! (otherwise you will find JFGES empty)
  //
  //   return values:
  //                    0 : event OK (no glitch found)
  //               [1-12] : no glitch found on slab [1-12]
  //
  // --------------------------------------------------------------------
  // --- equivalent FORTRAN code in TOFDEC (fidarc-v517: 20/04/2005) ---
  // --------------------------------------------------------------------
  // C         Check the CFD shift in TOFINO
  // C
  //       LISLB = LQ(JFGES - 1)
  //       DO WHILE (LISLB .NE. 0)
  //          IF((IQ(LISLB+4) .NE. 0) .AND. (IQ(LISLB+5) .NE. 0)) THEN
  //             TDCDIFF = ABS(Q(LISLB+9)-Q(LISLB+10))
  //             TDCSUM  = ABS(Q(LISLB+9)+Q(LISLB+10))
  //             IF(TDCDIFF.GT.7.3 .AND. TDCDIFF.LT.25.0 .AND.
  //      +         TDCSUM.LT.60.0) THEN
  //                IQ(JFGES+6) = 1  ! Set the flag for CFD shift
  //             ENDIF
  //          ENDIF
  //          LISLB = LQ(LISLB)
  //       END DO
  // C
  //       END
  // --------------------------------------------------------------------

  Float_t th_dif1 =  7.3;  // TDC difference absolute lower threshold (ns)
  Float_t th_dif2 =  25.0; // TDC difference absolute upper threshold (ns)
  Float_t th_sum = 60.0;   // TDC sum absolute threshold (ns)
  Int_t JFGES = prec->GetJFGES();
  if(!JFGES) return 0;
  Int_t L_ISLB = prec->GetLQ()[JFGES-1];
  while (L_ISLB){
    if(!prec->GetIQ()[L_ISLB+4] || !prec->GetIQ()[L_ISLB+5]){
      L_ISLB = prec->GetLQ()[L_ISLB];
      continue;
    }
    Float_t tdif = TMath::Abs(prec->GetQ()[L_ISLB+9]-prec->GetQ()[L_ISLB+10]);
    Float_t tsum = TMath::Abs(prec->GetQ()[L_ISLB+9]+prec->GetQ()[L_ISLB+10]);
    Int_t sl = prec->GetIQ()[L_ISLB+1];
    if(fDebugLev>1)
      Info("CheckTofinoCFDs", "checking slab %d", sl);
    if(tdif>th_dif1 && tdif<th_dif2 && tsum < th_sum){
      if(fDebugLev)
        if(fCurLogFile) *fCurLogFile << "Tofino glitch detected (slab " << sl << " - ev: " << prec->GetIQ()[JFGES+2] <<  " )" << endl;       
      //      Warning("CheckTofinoCFDs", "Tofino glitch detected on slab %d at event %d", sl, prec->GetIQ()[JFGES+2]);
      if(fDebugLev>1)
        Info("CheckTofinoCFDs", "reconstruction evaluation: CFD bad = %d", prec->GetIQ()[JFGES+6]);
      return sl;
    }
    L_ISLB = prec->GetLQ()[L_ISLB];
  }
  if(fDebugLev>1)
    Info("CheckTofinoCFDs", "NO Tofino glitch detected at event %d ---  reconstruction evaluation: CFD bad = %d",
         prec->GetIQ()[JFGES+2], prec->GetIQ()[JFGES+6]);
  return 0;
}

---