STEER/TFndRdt.cxx

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

//                                                                      //
//                               TFndRdt                                //
//                                                                      //
// This class gives the Description of the Raw Data Tape event.         //
// The private part includes some data members                          //
// (event length, pointers to the whole buffer and the subdetector      //
// buffers) and a set of member functions retrieving some information   //
// needed to build the Hit Data Tape.                                   //
// The public part allows to dump the event and invoke the member       //
// functions which transform the RDT sub-events into HDT sub-events.    //
//                                                                      //

#include "TApplication.h"

#include "TObjectTable.h"
#include "TBranch.h"
#include "TVector.h"
#include "TFndFeeMap.h"
#include "TFndRun.h"
#include "TFndRdt.h"
#include "TFndHdt.h"
#include "TFndTrig.h"
#include "TFndHTof.h"
#include "TFndHLmd.h"
#include "TFndRunConfiguration.h"

#include "TThread.h"

#include "TFndGeometry.h"

ClassImp(TFndRdt)

//____________________________________
TFndRdt::TFndRdt():
  fCurRunType(),fFndFeeMap(),
  fMustEvalCommonMode(),fMustFindSilClusters()
{
  // Debug levels are obtained according to the detectors "enum EFndMonDetectors" (see FROOT.h)
  
  Reload();
}

//____________________________________
TFndRdt::~TFndRdt() {  

  Reset();
  
}

//_____________________________________________
UInt_t *TFndRdt::GetDetector(E_FIN_RDT_DetID det_id){
  // offset (7) taken into account
  UInt_t *det = (fRawEvent[7 + det_id])?  fRawEvent+fRawEvent[7 + det_id] : NULL;
  return det;
  
}

//_____________________________________________
UInt_t *TFndRdt::GetEquipment(E_FIN_RDT_DetID det_id,Int_t eqp_num){
  // offset (6) taken into account
  
  //  UInt_t *det = (fRawEvent[7 + det_id])?  fRawEvent+fRawEvent[7 + det_id] : NULL;
  UInt_t *det = GetDetector(det_id);
  UInt_t *equ = (det && det[6 + eqp_num])?  det+det[6 + eqp_num] : NULL;
  return equ;
  
}

//_____________________________________________
void TFndRdt::PrintEquipment(Int_t eqp_id, Int_t neqp) {
  // to be implemented (if really needed)

  if(eqp_id == 2 || eqp_id == 3){
    Warning("PrintEquipment","No equipment loaded for SIL");
    return;
  }
  
}

//____________________________________
void TFndRdt::Reload(){
  
  Reset();
  fDebugLev = fndrun->GetDebugRawEv();
  fndrun->GetRunType(fCurRunType);
  if(!fndrun) TerminateFroot(0,"TFndRdt::TFndRdt() ---> pointer to TfndRun not available!");
  fFndFeeMap = fndrun->GetFeeMap();
  if(!fFndFeeMap) TerminateFroot(0,"TFndRdt::TFndRdt() ---> fFndFeeMap not ready!");
}

//____________________________________
void TFndRdt::Reset(){
  // Come back to the just created object
  
  //  delete fCurHdtEv;
  //  fCurHdtEv = 0;
  fRawEvent = 0;
  fSilHits.clear();
  fMustEvalCommonMode = kFALSE;
  fMustFindSilClusters = kFALSE;
}

//____________________________________
void TFndRdt::RdtToHdt(UInt_t *raw,TFndHdt* fndhdt) {
  //  ------------------------------
  // | Build the HDT complete event |
  //  ------------------------------
  
  if(!fFndFeeMap->IsThere()){
    Error("RdtToHdt","fFndFeeMap not available");
    gApplication->Terminate();
  }

  //fCurHdtEv = fndrun->GetCurrentHdt();
  //  fCurHdtEv = fndhdt;
  //  Printf("fCurHdtEv in TFndRdt: 0x%x",fCurHdtEv);
  if(!TFndRun::fgFinHdt){
    Error("RdtToHdt","TFndRun::fgFinHdt not defined!");
    gApplication->Terminate();
  }
  fRawEvent = raw;

  if(fDebugLev) Printf("TFndRdt::RdtToHdt ---> HEADER");

  if(fDebugLev) Printf("TFndRdt::RdtToHdt ---> Detector Trees");
#ifdef _FND_ENABLE_RAW_GTS
  if ( FillGtsHit() == -4 || FillGtsHit() == -3 || FillGtsHit() == -1 ) return; // -2 accepted for PEDE runs
#endif
#ifdef _FND_ENABLE_RAW_TOF
  FillTofHits();
#endif
#ifdef _FND_ENABLE_RAW_ISIM
  FillSilHits((Int_t) E_FIN_INNER_LAYER); // ISIM
#endif
#ifdef _FND_ENABLE_RAW_OSIM
  FillSilHits((Int_t) E_FIN_OUTER_LAYER); // OSIM
#endif
  //#if defined _FND_ENABLE_RAW_ISIM && defined  _FND_ENABLE_RAW_OSIM
  if(fMustEvalCommonMode) EvalCommonModeNoise();
  if(fMustFindSilClusters) FindSilClusters();
  //#endif
#ifdef _FND_ENABLE_RAW_LMD
  FillLmdHits();
#endif
#ifdef _FND_ENABLE_RAW_STB
  FillStbHits();
#endif

  if(fDebugLev) Printf("TFndRdt::RdtToHdt ---> Exiting method");
}

//____________________________________
Int_t TFndRdt::FillGtsHit() {
  // return value:
  //               0 : normal buffer
  //              -1 : wrong buffer (detector not in the run) (or wrong eqp length)
  //              -2 : wrong buffer (PU eqp not found)
  //              -3 : wrong buffer (PU pointer not found)
  //              -4 : wrong buffer (wrong PU length)
  //              -5 : (MALU eqp not found)
  //              -6 : (MALU pointer not found)
  //              -7 : (wrong MALU length)
  //              -8 : (TRIG-SEL eqp not found)
  //              -9 : (TRIG-SEL pointer not found)
  //              -10: (wrong TRIG-SEL length)

  UInt_t deb_gts = (fDebugLev >> ((Int_t)(D_GTS)*4)) & 0xF; // get gts digit

  UInt_t *det = GetDetector(FIN_RDT_Eqp_Gts);  
  if (det==NULL){
    if(fDebugLev > 0) Warning("FillGtsHit","detector not in the run (null pointer)");
    return -1; //
  }
  // GTS equipment
  
  // --- Pattern Unit
  UInt_t *eqp = GetEquipment( FIN_RDT_Eqp_Gts, FIN_EQ_CAEN_V529 );
  if(!eqp){
    if( fCurRunType != (Int_t)(RT_PEDE) )
      Warning("FillGtsHit","Pointer to PU equipment is NULL");
    return -2;
  }
  UInt_t *pu_ptr=eqp+1;
  if(!pu_ptr){
    Error("FillGtsHit","Pointer to the PU structure is NULL");    
    return -3;
  }
  
  if(eqp[0] <= 0 || eqp[0] > K_MAX_EQP_LEN) {
    Error("FillGtsHit","Wrong length found in GTS equipment");
    return -1;
  }
  
  UInt_t pu_len=eqp[0]-1;
  if(deb_gts>0) Printf("TFndRdt::FillGtsHit -----> Reading Pattern Units");
  if(pu_len <= 1 || pu_len > K_N_GTS_P_UNITS * 2) {
    Error("FillGtsHit","PU length not accepted: value= %u",pu_len);
    return -4;
  } 
  for(UInt_t i=0;i<pu_len;i++) {
    UInt_t cont = 0;
    UInt_t mult = 0;
    if(i%2 == 0){
      cont = *(pu_ptr + i) & 0xFFFF;
      TFndRun::fgFinHdt->GetGts()->SetPU_cont(cont,i/2);
    }    
    else{
      mult = *(pu_ptr + i) & 0xFFFF;
      TFndRun::fgFinHdt->GetGts()->SetPU_mult(mult,(i/2)+1);
    }    
  }
  if(deb_gts>1){
    for(UInt_t i=0;i<K_N_GTS_P_UNITS;i++) 
      Printf("TFndRdt::FillGtsHit -----> PU(id:%u): content: 0x%x; mult:0x%x",
                      i,
                      TFndRun::fgFinHdt->GetGts()->GetPU_cont(i),
                      TFndRun::fgFinHdt->GetGts()->GetPU_mult(i));
  }

  // --- MALU
  eqp = GetEquipment( FIN_RDT_Eqp_Gts, FIN_EQ_LECROY_4532);
  if(!eqp){
    if(deb_gts>0) Error("FillGtsHit","Pointer to MALU equipment is NULL");
    return -5;
  }
  UInt_t *mu_ptr=eqp+1;
  if(!mu_ptr){
    Error("FillGtsHit","Pointer to the MALU structure is NULL");    
    return -6;
  }
  UInt_t mu_len=eqp[0]-1;
  if(deb_gts>0) Printf("TFndRdt::FillGtsHit -----> Reading MALU(s)");
  if(mu_len <= 1 || mu_len > K_N_GTS_MALU * 2) {
    Error("FillGtsHit","MALU length not accepted: value= %u",mu_len);
    return -7;
  } 
  UInt_t pat1 = 0;
  UInt_t pat2 = 0;
  if(deb_gts>0) Printf("TFndRdt::FillGtsHit -----> MALU length: %u",mu_len);
  for(UInt_t i=0;i<mu_len;i++) {
    if(i%2 == 0) pat1 = *(mu_ptr + i) & 0xFFFF;    
    else{
      pat2 = *(mu_ptr + i) & 0xFFFF;
      TFndRun::fgFinHdt->GetGts()->SetMalu_cont(pat1,pat2,(i/2));
      pat1 = 0; pat2 = 0;
    }
  }    
  
  if(deb_gts>1){
    for(UInt_t i=0;i<K_N_GTS_MALU;i++) 
      Printf("TFndRdt::FillGtsHit -----> MALU(id:%u): content: 0x%x;",
                      i,
                      TFndRun::fgFinHdt->GetGts()->GetMalu_cont(i));
  }
  // --- TRIGGER SELECTOR
  eqp = GetEquipment( FIN_RDT_Eqp_Gts, FIN_EQ_TRIG_SEL);
  if(!eqp){
    Error("FillGtsHit","Pointer to TRIGGER SELECTOR equipment is NULL");
    return -8;
  }
  UInt_t *ts_ptr=eqp+1;
  if(!ts_ptr){
    Error("FillGtsHit","Pointer to the TRIGGER SELECTOR structure is NULL");    
    return -9;
  }
  UInt_t ts_len=eqp[0]-1;
  if(deb_gts>0) Printf("TFndRdt::FillGtsHit -----> Reading TRIGGER SELECTOR");
  if(ts_len <= 1 || ts_len > K_N_GTS_SELECTORS) {
    Error("FillGtsHit","TRIGGER SELECTOR length not accepted: value= %u",ts_len);
    return -10;
  }
  if(deb_gts>0) Printf("TFndRdt::FillGtsHit -----> Trigger Selector length: %u",ts_len);
  for(UInt_t i=0;i<ts_len;i++) {
    TFndRun::fgFinHdt->GetGts()->SetTriggerSelector(*(ts_ptr+i),i);
  }    
  
  if(deb_gts>1){
    for(UInt_t i=0;i<K_N_GTS_SELECTORS;i++) 
      Printf("TFndRdt::FillGtsHit -----> TrigSel(id:%u): content: 0x%x;",
                      i,
                      TFndRun::fgFinHdt->GetGts()->GetTriggerSelector(i));
  }

  return 0;
}

//____________________________________
void TFndRdt::FillSilHits(Int_t io) {
  // Rewritten (September 2006)
  // hit = new TFndHSil(nmodule,nside,nadc,nstrip,noise,spych,adc);
  
  UInt_t *det = (io == 1 ) ? GetDetector(FIN_RDT_Eqp_Isi) : GetDetector(FIN_RDT_Eqp_Osi);  
  if (det==NULL){
    if(fDebugLev > 0) Warning("FillSilHits","detector not in the run (null pointer) (io = %d)",io);
    return;
  }

  UInt_t deb_sil = (fDebugLev >> ((Int_t)(D_SIL)*4)) & 0xF; // get sil digit

  // 2006 hardware has different base address for CRAMS
  Int_t b_addr = K_Sil_Crams_BaseAddress_03;
  if(fndrun->GetRunTime() > Fee_2006_NewSilDB_StartTime) b_addr = K_Sil_Crams_BaseAddress_06;

  if(deb_sil) Printf( "TFndRdt::FillSilHits ---> using base address 0x%x",b_addr);
  int cram;
  int sez;
  for (int k=3,h=0; k<det[0]; k++,h--) {
    static int PhBuf[0x2000],ZaBuf[0x1000],ZbBuf[0x1000],*Buf;
    static int ll;
    static int j,jza,jzb;
    //       static SILDBADC *db;
    
    //---------------------
    
    if (h==0) {
      cram = ((det[k++]>>16) & 0xFFFF) - b_addr;
      if (cram >= 0x60 || cram < 0) break;
      
      sez  = det[k++];
      if (sez != 0 && sez != 1) break;
      
      h = det[k];
      if (h) k++;
      j=0;
    }
      
    //---------------------
    int is_spy    = (det[k]>>31) & 1;        // spy channal flag
    int noise     = (det[k]>>23) & 0xFF;     // noise value
    int n_adc_cha = (det[k]>>12) & 0x3FF;    // cram channel number
    int adc_val   = det[k]       & 0x3FF;    // adc value
    
    // typedef struct {
    //   Char_t  Module;               // Module number
    //   Char_t  P_Z;                  // 0=Phi 1=Za  2=Zb
    //   char  Spy[K_N_Sil_AdcCha];   // 1=Spy
    //   char  Noise[K_N_Sil_AdcCha]; // Noise level: 0=OK ... 6=dead
    //   short Strip[K_N_Sil_AdcCha]; // Strip number
    //   short Chip[K_N_Sil_AdcCha];  // Chip (VA1) number
    //   float Amp[K_N_Sil_AdcCha];   // Strip amplification
    // } SILDBADC;
    
    if(deb_sil>1) Printf("TFndRdt::FillSilHits -----> is_spy %d; noise %d; n_adc_cha %d; adc_val %d.", is_spy, noise, n_adc_cha, adc_val);
    //    
    Short_t nmodule = fFndFeeMap->GetSilModule(io,cram,sez);
    Short_t nside = fFndFeeMap->GetSilSide(io,cram,sez);
    //      Short_t nadc = cha; // unique variable will be used
    Short_t nstrip = fFndFeeMap->GetSilStrip(io,cram,sez,n_adc_cha);
    //      Short_t noise = noi; // check
    //      Short_t spych = spy;
    //      Float_t adc = val;
    
    // histos:
    // - per ogni module/side ===> noise vs n_adc_cha (TH1) // resetteto evento per evento
    // - valutare common-mode e varianza
    // - valutazione del cluster
    //      |
    //      + -> per ogni module/side ==> cluster charge
    
    if(deb_sil>1) Printf("TFndRdt::FillSilHits -----> layer %d; nmodule %d; nside %d; nstrip %d.", io, nmodule, nside, nstrip);
    
    SILADCHIT s_hit;
    s_hit.Layer  = (Int_t) io;
    s_hit.Module = (Int_t) nmodule;
    s_hit.Side   = (Int_t) nside;
    s_hit.Strip  = (Int_t) nstrip;
    s_hit.Spy    = (Int_t) is_spy;
    s_hit.Noise  = (Int_t) noise;
    s_hit.AdcCh  = (Int_t) n_adc_cha;
    s_hit.AdcVal = (Int_t) adc_val - (Int_t) K_N_Sil_FixPede;
    fSilHits.push_back(s_hit);
    
    //       TFndHSil *hit; // the TFndHSil class will be removed
    //       //      if(noise > 5) {
    //       hit = new TFndHSil(nmodule,nside,nadc,nstrip,noise,spych,adc);
    //       //    if(fDebugLev) hit->Print();
    //       if(nmodule < 10) 
    //          fCurHdtEv->AddIsmHit(hit); 
    //       else 
    //          fCurHdtEv->AddOsmHit(hit); 
    //}
  }

  fMustEvalCommonMode = kTRUE;
  fMustFindSilClusters = kTRUE;
  if(deb_sil) Printf("TFndRdt::FillSilHits ---> exiting method");
}
    
//____________________________________
void TFndRdt::EvalCommonModeNoise() {
  // Check the list of hits on SIL first
  if(fSilHits.empty()){
    Warning("EvalCommonModeNoise","List of SIL hits empty");
    return;
  }
  Bool_t vfound = kFALSE;
  // Check if you need to set at zero all vectors!
  // Clear Common Mode mean max count vectors on hdt.  
  // Printf("EvalCommonMode: Clear Common Mode Vectors");

  //  TFndRun::fgFinHdt->SetSilComMod_meanmaxcount_zero(); 

  // get an iterator to the starting point of the vector
  // Printf("EvalCommonMode: First Loop on Hits");
  for(std::vector<SILADCHIT>::iterator itNum = fSilHits.begin(); itNum < fSilHits.end(); itNum++){ // loop on all hits
    // maximum number of hits: 55296
    //
    // Set SIL-noise
    TFndRun::fgFinHdt->SetSilNoise(itNum->AdcCh,itNum->Side, itNum->Module, itNum->Layer, itNum->Noise) ;
    // Fill the CM mean value
    if (itNum->Spy == 1) TFndRun::fgFinHdt->FillSilComMod_mean((itNum->AdcCh)/(Int_t)K_N_Sil_ChaOnChip,itNum->Side, itNum->Module, itNum->Layer, (Double_t) itNum->AdcVal) ;
    //
    //
  } // first loop on all hits completed  
  // Calculate the Common Mode
  //  Printf("EvalCommonMode: Calculate Common Mode");
  TFndRun::fgFinHdt->CalculateSilComMod_mean_all();
  // Subtract the Common Mode to the spy channels 
  // Printf("EvalCommonMode: Second Loop on Hits");
  for(std::vector<SILADCHIT>::iterator itNum = fSilHits.begin(); itNum < fSilHits.end(); itNum++){ // loop on all hits
    if (itNum->Spy == 1) itNum->AdcVal -=  TFndRun::fgFinHdt->GetIntSilComMod_mean((itNum->AdcCh)/(Int_t)K_N_Sil_ChaOnChip,itNum->Side, itNum->Module, itNum->Layer);
  } // second loop on all hits completed  
}

//____________________________________
void TFndRdt::FindSilClusters(){
  //
  // the raw-datum reading is completed: now create or update hits      
  // Printf("Finding Sil Cluster...");
  //
  SetAdc_Val_Noi_Zero();
  //
  std::vector<SILCLRAW> PhiSilCluster;
  std::vector<SILCLRAW> ZetaSilCluster;
  //
  Double_t PhiKaonThreshold[8] = 
    { 
      200.,
      200.,
      170.,
      170.,
      150.,
      160.,
      180.,
      200.
    };
  
  //
  SILCLRAW SilCluster;
  //
  for(std::vector<SILADCHIT>::iterator itNum = fSilHits.begin(); itNum < fSilHits.end(); itNum++){ // loop on all hits
    SetSilAdcVal(itNum->Layer,itNum->Module,(itNum->Side < 1 ? 0 : 1),itNum->Strip,itNum->AdcVal);
    SetSilAdcNoi(itNum->Layer,itNum->Module,(itNum->Side < 1 ? 0 : 1),itNum->Strip,itNum->Noise);
    SetSilAdcCh(itNum->Layer,itNum->Module,(itNum->Side < 1 ? 0 : 1),itNum->Strip, (itNum->Side < 2 ? itNum->AdcCh : itNum->AdcCh + (Int_t) K_N_Sil_AdcCha ));
    //
  }
  //
  for(Int_t nlay = 1; nlay < (Int_t) E_FIN_OUTER_LAYER+1; nlay++){
    for(Int_t nmod = 1; nmod < (Int_t) K_N_Sil_Modules+1; nmod++) {
      PhiSilCluster.clear();
      ZetaSilCluster.clear();
      Double_t dedx_phi_cosalpha = 0.;
      Double_t dedx_zeta_cosalpha = 0.;
      for(Int_t nside = 0; nside < (Int_t) K_N_Sil_Sides - 1; nside++) {
        //
        Int_t nstrip = 1;
        Int_t nclustr = 0;
        Int_t nminstr = 0;
        Int_t nmaxstr = 0;
        Int_t nadcchcl = 0;
        Double_t strcomcl = 0.;
        Double_t noisecl = 0.;
        Double_t adcvalcl = 0.;
        Double_t bar_pre = 0.;
        Double_t sum_pre = 0.;
        Double_t noi_pre = 0.;
        Int_t nst_pre = 0;
        //
        Int_t MaxStrSide = ( nside < 1 ? (Int_t) K_N_Sil_Phi_Strips : (Int_t) K_N_Sil_Z_Strips );
        //
        // simple cluster finding algorithm
        //
        //
        while (nstrip <= MaxStrSide) {
          //
          if (((GetSilAdcVal(nlay,nmod,nside,nstrip)*(Int_t)K_N_Sil_MulNoise) > (GetSilAdcNoi(nlay,nmod,nside,nstrip)*(Int_t)K_N_Sil_Sigma_Pre)) && (GetSilAdcNoi(nlay,nmod,nside,nstrip) > (Int_t)K_N_Sil_Noise_Cut)) {
            //
            nclustr = nstrip; 
            while((nclustr >= 1) && ((GetSilAdcVal(nlay,nmod,nside,nclustr)*(Int_t)K_N_Sil_MulNoise) > (GetSilAdcNoi(nlay,nmod,nside,nclustr)*(Int_t)K_N_Sil_Sigma_Cut))) nclustr--;
            nminstr = nclustr+1;
            // 
            nclustr = nstrip; 
            while((nclustr <= MaxStrSide) && ((GetSilAdcVal(nlay,nmod,nside,nclustr)*(Int_t)K_N_Sil_MulNoise) > (GetSilAdcNoi(nlay,nmod,nside,nclustr)*(Int_t)K_N_Sil_Sigma_Cut))) nclustr++;
            nmaxstr = nclustr-1;
            // prepare for next cluster
            nstrip = nclustr;
            // calculation of cluster parameter
            bar_pre = 0.;
            sum_pre = 0.;
            noi_pre = 0.;
            nst_pre = 0;
            //
            for (Int_t nstr = nminstr; nstr <= nmaxstr; nstr++) {
              bar_pre += (((Double_t)GetSilAdcVal(nlay,nmod,nside,nstr))*((Double_t)nstr));   
              sum_pre += ((Double_t)GetSilAdcVal(nlay,nmod,nside,nstr));
              noi_pre += (((Double_t)GetSilAdcNoi(nlay,nmod,nside,nstr))*((Double_t)GetSilAdcNoi(nlay,nmod,nside,nstr)));
              nst_pre++; 
            }
            strcomcl = (sum_pre != 0. ? bar_pre/sum_pre : -1.);
            noisecl = (noi_pre > 0 ? sqrt(noi_pre) : -1.);
            adcvalcl = sum_pre;
            nadcchcl = GetSilAdcCh(nlay,nmod,nside,lrint(strcomcl));
            // here store the value of Phi and Z cluster
            SilCluster.NumStripCl = nst_pre; // Min Strip Number of Cluster
            SilCluster.AdcChCl = nadcchcl;   // Center of Mass of Cluster (adc channel) 
            SilCluster.StripChCl = strcomcl; // Center of Mass of Cluster
            SilCluster.NoiseCl = noisecl;    // Noise level of Cluster
            SilCluster.AdcValCl = adcvalcl;  // Sum Adc Values of Cluster
            //
            //      Printf("TFndRdt::FindSilCluster -----> Cluster: min_str %d; max_str %d; num_str %d; num_int %d; bar_cha %f; n_adc_bar_cha %f; charge %f; noise %f. ", nminstr,nmaxstr,nst_pre,lrint(strcomcl),(Float_t) strcomcl,(Float_t) nadcchcl,(Float_t) adcvalcl,(Float_t) noisecl);      
            //
            if (nside == 0) { 
              PhiSilCluster.push_back(SilCluster);
            } else {
              ZetaSilCluster.push_back(SilCluster);
            }
            // ...
          } else {
            nstrip++; 
          } // end of high threshold if
        } // end of while (nstrip ...)
      } // end of side loop
      // Sort the cluster vectors
      std::sort(PhiSilCluster.begin(), PhiSilCluster.end(), SDescendingAdcValClSort());
      std::sort(ZetaSilCluster.begin(), ZetaSilCluster.end(), SDescendingAdcValClSort());
      // here insert the Phi and Z Cluster association
      // diff_adc_val = 0.;
      //
      Double_t diff_adc_val = -1.;
      std::vector<SILCLRAW>::iterator itStopPhi = PhiSilCluster.begin();
      std::vector<SILCLRAW>::iterator itStopZeta = ZetaSilCluster.begin();
      // loop on all phi cluster
      if ( (!PhiSilCluster.empty()) && (!ZetaSilCluster.empty()) ) {
        for(std::vector<SILCLRAW>::iterator itPhi = PhiSilCluster.begin(); itPhi < PhiSilCluster.end(); itPhi++){ 
          //
          diff_adc_val = -1.;
          // loop on all zeta cluster
          for(std::vector<SILCLRAW>::iterator itZeta = ZetaSilCluster.begin(); itZeta < ZetaSilCluster.end(); itZeta++){ 
            //
            if(diff_adc_val==-1.) {
              diff_adc_val = TMath::Abs(itPhi->AdcValCl - itZeta->AdcValCl);
              itStopPhi = itPhi; 
              itStopZeta = itZeta;
            }
            //
            if(diff_adc_val > TMath::Abs(itPhi->AdcValCl - itZeta->AdcValCl)) {
              diff_adc_val = TMath::Abs(itPhi->AdcValCl - itZeta->AdcValCl) ;
              itStopPhi = itPhi; 
              itStopZeta = itZeta;
            }     
          } //end loop on zeta cluster
          //
          // Printf("Found Sil Cluster");
          //
          // fill the hit cluster vector
          //
          TFndHSilCluster * hsilcl = TFndRun::fgFinHdt->Add_SilCluster(nlay);
          if ( diff_adc_val >= 0. ) {
            hsilcl->SetModNum(nmod);
            hsilcl->SetGoodCl(1);
            hsilcl->SetIDCl(0);
            hsilcl->SetClusterPhiAdcCh((Float_t) itStopPhi->AdcChCl);
            hsilcl->SetClusterZetaAdcCh((Float_t) itStopZeta->AdcChCl);
            hsilcl->SetLocalPosition(0.0,TFndGeometry::SilPositionStrip(0,itStopPhi->StripChCl),TFndGeometry::SilPositionStrip(1,itStopZeta->StripChCl));
            hsilcl->SetPhiClusterSignal((Float_t) itStopPhi->AdcValCl );
            hsilcl->SetPhiClusterNoise((Float_t) itStopPhi->NoiseCl);
            hsilcl->SetZetaClusterSignal((Float_t) itStopZeta->AdcValCl );
            hsilcl->SetZetaClusterNoise((Float_t) itStopPhi->NoiseCl); 
            dedx_phi_cosalpha = (itStopPhi->AdcValCl / TMath::Sqrt(1.+((Double_t)(itStopPhi->NumStripCl*itStopPhi->NumStripCl))/36.+ ((Double_t)(itStopZeta->NumStripCl*itStopZeta->NumStripCl)/9.)));
            dedx_zeta_cosalpha = (itStopZeta->AdcValCl / TMath::Sqrt(1.+((Double_t)(itStopPhi->NumStripCl*itStopPhi->NumStripCl))/36.+ ((Double_t)(itStopZeta->NumStripCl*itStopZeta->NumStripCl)/9.)));
            hsilcl->SetDEDxPhi((Float_t) dedx_phi_cosalpha);
            hsilcl->SetDEDxZeta((Float_t) dedx_zeta_cosalpha);
            if (nlay == 1 && dedx_phi_cosalpha > PhiKaonThreshold[nmod-1]) hsilcl->SetIDCl(1);
            // erase zeta cluster
            ZetaSilCluster.erase(itStopZeta);
          } else { 
            hsilcl->SetModNum(nmod);
            hsilcl->SetGoodCl(0);
            hsilcl->SetIDCl(0);
            hsilcl->SetClusterPhiAdcCh(itPhi->AdcChCl);
            hsilcl->SetClusterZetaAdcCh(-1.);
            hsilcl->SetLocalPosition(0.0,TFndGeometry::SilPositionStrip(0,itPhi->StripChCl),0.0);
            hsilcl->SetPhiClusterSignal((Float_t) itPhi->AdcValCl );
            hsilcl->SetPhiClusterNoise((Float_t) itPhi->NoiseCl);
            hsilcl->SetZetaClusterSignal(-1.);
            hsilcl->SetZetaClusterNoise(-1.); 
            hsilcl->SetDEDxPhi(-1.);
            hsilcl->SetDEDxZeta(-1.);
          }
        } //end loop on phi cluster
        // reloop on remaining zeta clusters
        if (!ZetaSilCluster.empty()) {
          for(std::vector<SILCLRAW>::iterator itZeta = ZetaSilCluster.begin(); itZeta < ZetaSilCluster.end(); itZeta++){
            TFndHSilCluster * hsilcl = TFndRun::fgFinHdt->Add_SilCluster(nlay);
            //
            hsilcl->SetModNum(nmod);
            hsilcl->SetGoodCl(0);
            hsilcl->SetIDCl(0);
            hsilcl->SetClusterPhiAdcCh(-1.);
            hsilcl->SetClusterZetaAdcCh((Float_t) itZeta->AdcChCl);
            hsilcl->SetLocalPosition(0.0,0.0,TFndGeometry::SilPositionStrip(1,itZeta->StripChCl));
            hsilcl->SetPhiClusterSignal(-1.);
            hsilcl->SetPhiClusterNoise(-1.);
            hsilcl->SetZetaClusterSignal((Float_t) itZeta->AdcValCl);
            hsilcl->SetZetaClusterNoise((Float_t) itZeta->NoiseCl); 
            hsilcl->SetDEDxPhi(-1.);
            hsilcl->SetDEDxZeta(-1.);
          }
        }
      } else if (!PhiSilCluster.empty()) {
        for(std::vector<SILCLRAW>::iterator itPhi = PhiSilCluster.begin(); itPhi < PhiSilCluster.end(); itPhi++){ 
          TFndHSilCluster * hsilcl = TFndRun::fgFinHdt->Add_SilCluster(nlay);
          //
          hsilcl->SetModNum(nmod);
          hsilcl->SetGoodCl(0);
          hsilcl->SetIDCl(0);
          hsilcl->SetClusterPhiAdcCh((Float_t) itPhi->AdcChCl);
          hsilcl->SetClusterZetaAdcCh(-1.);
          hsilcl->SetLocalPosition(0.0,TFndGeometry::SilPositionStrip(0,itPhi->StripChCl),0.0);
          hsilcl->SetPhiClusterSignal((Float_t) itPhi->AdcValCl );
          hsilcl->SetPhiClusterNoise((Float_t) itPhi->NoiseCl);
          hsilcl->SetZetaClusterSignal(-1.);
          hsilcl->SetZetaClusterNoise(-1.); 
          hsilcl->SetDEDxPhi(-1.);
          hsilcl->SetDEDxZeta(-1.);
        }
      } else if (!ZetaSilCluster.empty()) {
        for(std::vector<SILCLRAW>::iterator itZeta = ZetaSilCluster.begin(); itZeta < ZetaSilCluster.end(); itZeta++){
          TFndHSilCluster * hsilcl = TFndRun::fgFinHdt->Add_SilCluster(nlay);
          //
          hsilcl->SetModNum(nmod);
          hsilcl->SetGoodCl(0);
          hsilcl->SetIDCl(0);
          hsilcl->SetClusterPhiAdcCh(-1.);
          hsilcl->SetClusterZetaAdcCh((Float_t) itZeta->AdcChCl);
          hsilcl->SetLocalPosition(0.0,0.0,TFndGeometry::SilPositionStrip(1,itZeta->StripChCl));
          hsilcl->SetPhiClusterSignal(-1.);
          hsilcl->SetPhiClusterNoise(-1.);
          hsilcl->SetZetaClusterSignal((Float_t) itZeta->AdcValCl);
          hsilcl->SetZetaClusterNoise((Float_t) itZeta->NoiseCl); 
          hsilcl->SetDEDxPhi(-1.);
          hsilcl->SetDEDxZeta(-1.);
        }
      } // end if cluster empty
    } // end of module loop
  } // end of layer loop
  //
  //
  // TFndHSilCluster * hsilcl = TFndRun::fgFinHdt->Add_SilCluster(layer);
  // hsilcl->SetModNum(Int_t mod_num);
  //
  // hit creation (or update) completed
  //
}


//____________________________________
void TFndRdt::FillTofHits() {
  
  UInt_t *det = GetDetector(FIN_RDT_Eqp_Tof);  
  if (det==NULL){
    if(fDebugLev > 0) Warning("FillTofHits","detector not in the run (null pointer)");
    return;
  }
  
  FillTofAdcHits(det);
  FillTofTdcHits(det);
}

//____________________________________
void TFndRdt::FillTofAdcHits(UInt_t *det) {

  UInt_t deb_tof = (fDebugLev >> ((Int_t)(D_TOF)*4)) & 0xF; // get tof digit

  // ADC equipment
  if(deb_tof) Printf("TFndRdt::FillTofAdcHits ---> ADC equipment");
  UInt_t *eqp = GetEquipment( FIN_RDT_Eqp_Tof, FIN_EQ_CAEN_VN1485 );
  if(!eqp){
    Error("FillTofAdcHits","Pointer to the required equipment is NULL");
    return;
  }
  UInt_t *ladcptr=eqp+1;
  if(!ladcptr){
    Error("FillTofAdcHits","Pointer to the adc structure is NULL");    
    return;
  }

  if(eqp[0] <= 0 || eqp[0] > K_MAX_EQP_LEN) {
    Error("FillTofAdcHits","adc length not accepted: value= %u",eqp[0]);
    return;
  }
  UInt_t ladclen=eqp[0]-1;
  if(deb_tof) Printf("TFndRdt::FillTofAdcHits ---> ADC length: %u",ladclen);  
  if(ladclen == 0 ) return;

  Int_t tof_adc_cnt = 0;
  Int_t tof_adc_chn = 0;
  Int_t tof_adc_brd = 0;

  Int_t n_conv = 0;  

  Int_t tof_bit = 0; // check if the current value is valid
  Int_t cur_slab = 0;
  Int_t is_side_p = -1; // 0:e-side ; 1: p-side

  //  Bool_t is_new_hit = kFALSE;
  
  Int_t i=0;
  while(i < (Int_t) ladclen-1) {
    if(i>0) { ladcptr++; i++; }
    n_conv = *ladcptr;
    if(deb_tof) Printf( "TFndRdt::FillTofAdcHits ---> %d conversions",n_conv);
    for(Int_t k=0;k<n_conv;k++) {
      i++;
      ladcptr++;
      tof_bit = (Int_t) ((*ladcptr)>>0xD)&0x1;
      if(tof_bit != 0) { continue; }
      tof_adc_cnt = (Int_t) (*ladcptr)&0xFFF;
      tof_adc_chn = (Int_t) ((*ladcptr)>>0x10)&0x3F;
      tof_adc_brd = (Int_t) ((*ladcptr)>>0x17)&0x1F;
      if(deb_tof > 1) {
        Printf("TFndRdt::FillTofAdcHits ---> conv: %d ; EvtBuf Ch-data = 0x%x",k,(Int_t) (*ladcptr));
        Printf("TFndRdt::FillTofAdcHits -----> conv: %d ; tof_adc_cnt = %d",k,tof_adc_cnt);
        Printf("TFndRdt::FillTofAdcHits -----> conv: %d ; tof_adc_chn = %d",k,tof_adc_chn);
        Printf("TFndRdt::FillTofAdcHits -----> conv: %d ; tof_adc_brd = %d",k,tof_adc_brd);
      }
      //      cur_slab = fFndFeeMap->GetTofAdcSlb(tof_adc_brd-1,tof_adc_chn);
      cur_slab = fFndFeeMap->GetTofAdcSlb(tof_adc_brd,tof_adc_chn);
      //      is_side_p = fFndFeeMap->GetTofAdcSide(tof_adc_brd-1,tof_adc_chn);
      is_side_p = fFndFeeMap->GetTofAdcSide(tof_adc_brd,tof_adc_chn);
      if(deb_tof > 2) {
        Printf("TFndRdt::FillTofAdcHits --------> conv: %d ; cur_slab = %d",k,cur_slab);
        Printf("TFndRdt::FillTofAdcHits --------> conv: %d ; is_side_p = %d",k,is_side_p);
      }
      if(cur_slab <= 0 || cur_slab > 172){
        if(deb_tof > 2 && fCurRunType != RT_PEDE) Warning("FillTofAdcHits","Event %d: Adc board: %d, ch: %d not mapped inside DB",fRawEvent[2],tof_adc_brd,tof_adc_chn);
        continue;
      }
      if(cur_slab>300){
        Error("FillTofAdcHits","cur_slab (%d) should never occur with ADC",cur_slab);
        TerminateFroot();
      }
      // the raw-datum reading is completed: now create or update hits  
      TFndRun::fgFinHdt->Find_Add_TofHit(cur_slab,kTRUE)->SetAdc(tof_adc_cnt,(E_Fnd_Side)is_side_p);
      // hit creation (or update) completed
    }
    i++;
    ladcptr++;
  }
  if(deb_tof) Printf("TFndRdt::FillTofAdcHits ---> exiting method");
}
 
//____________________________________
void TFndRdt::FillTofTdcHits(UInt_t *det) {
  //  Bool_t fCheckHit_Tofino[K_N_SLABS_TOFINO];
  //  Bool_t fCheckHit_Tofone[K_N_SLABS_TOFONE];
    
  UInt_t deb_tof = (fDebugLev >> ((Int_t)(D_TOF)*4)) & 0xF; // get tof digit

  // TDC equipment
  if(deb_tof) Printf("TFndRdt::FillTofTdcHits ---> TDC equipment");
  UInt_t *eqp = GetEquipment( FIN_RDT_Eqp_Tof, FIN_EQ_CAEN_VN1488 );  
  if(!eqp){
    Error("FillTofTdcHits","Pointer to the required equipment is NULL");
    return;
  }
  UInt_t *ltdcptr = eqp+1;
  if(!ltdcptr){
    Error("FillTofTdcHits","Pointer to the tdc structure is NULL");    
    return;
  }

  if(eqp[0] <= 0 || eqp[0] > K_MAX_EQP_LEN) {
    Error("FillTofTdcHits","tdc length not accepted: value= %u",eqp[0]);
    return;
  }
  UInt_t ltdclen = eqp[0]-1;  
  if(deb_tof) Printf("TFndRdt::FillTofTdcHits ---> TDC length: %u",ltdclen);
  if(ltdclen == 0 ) return;

  Int_t tof_tdc_cnt = 0;
  Int_t tof_tdc_chn = 0; 
  Int_t tof_tdc_brd = 0;
  
  Int_t n_conv = 0;  // number of conversions
  Int_t tof_bit = 0; // check if the current value is valid
  
  Int_t tdcslb1 = 0; // SLAB number for CFD TDC (1-12: low-threshold; 300-312: high-threshold)
  Short_t is_side_p  = -1; // 0:e-side ; 1: p-side
  Int_t tdcmt1 = 0; // SLAB number for mean-timer TDC (1-12: low-threshold; 300-312: high-threshold)
  
  UShort_t WhichMod = 0;
  //  Bool_t is_new_hit = kFALSE;
  // --- available module types are:                                                //
  //       - CFD (Constant-Fraction-Discriminator) [low-threshold / high-threshold] //
  //       - MT  (Mean-Timer) [low-threshold / high-threshold]                      //
  //   They are identified by a 2-bit mask:                                         //
  //               - bit 0: threshold   (0: Low ; 1: High)                          //
  //               - bit 1: module type (0: CFD ; 1: MT)                            //
  //                                                                                //
  //                                                                                //
  //       UShort_t w = 0;                                                          //
  //       w = (w & (0x1));  // select cfd                                          //
  //       w = (w | (1<<1)); // select mt                                           //
  //       w = (w | (0x1));  // select high thr                                     //
  //       w = (w & (0x2));  // select low thr                                      //
  //                                                                                //
  //   The result is:                                                               //
  //     switch(w){                                                                 //
  //       case 0: [... CFD-LOW ...]                                                //
  //       case 1: [... CFD-HIGH ...]                                               //
  //       case 2: [... MT-LOW ...]                                                 //
  //       case 3: [... MT-HIGH ...]                                                //
  //     }                                                                          //
  //                                                                                //

  Int_t i=0;
  while(i < (Int_t) ltdclen-1) { // check "-1"
    if(i>0) { ltdcptr++; i++; }
    n_conv = *ltdcptr;
    if(deb_tof) Printf( "TFndRdt::FillTofTdcHits ---> %d conversions",n_conv);
    for(Int_t k=0;k<n_conv;k++) {
      i++;
      ltdcptr++;
      tof_bit = (Int_t) ((*ltdcptr)>>0xD)&0x1;
      if(tof_bit != 0) { continue; }
      tof_tdc_cnt = (Int_t) (*ltdcptr)&0xFFF;
      tof_tdc_chn = (Int_t) ((*ltdcptr)>>0x10)&0x3F;
      tof_tdc_brd = (Int_t) ((*ltdcptr)>>0x17)&0x1F;
      if(((Int_t) ((*ltdcptr)>>0xD)&0x2) != 0 && fCurRunType != RT_PEDE){
        cout << "TFndRdt::FillTofTdcHits Warning---> Tdc NO_HIT bit detected: event " << fRawEvent[2] << "; board: " << tof_tdc_brd << "; ch: " << tof_tdc_chn << endl;
        //Printf("TFndRdt::FillTofTdcHits Warning---> Tdc NO_HIT bit detected: event %d; board: %d, ch: %d",fRawEvent[2],tof_tdc_brd,tof_tdc_chn);
        continue;
      }
      if(deb_tof > 1) {
        Printf("TFndRdt::FillTofTdcHits ---> conv: %d ; EvtBuf Ch-data = 0x%x",k,(Int_t) (*ltdcptr));
        Printf("TFndRdt::FillTofTdcHits -----> conv: %d ; tof_tdc_cnt = %d",k,tof_tdc_cnt);
        Printf("TFndRdt::FillTofTdcHits -----> conv: %d ; tof_tdc_chn = %d",k,tof_tdc_chn);
        Printf("TFndRdt::FillTofTdcHits -----> conv: %d ; tof_tdc_brd = %d",k,tof_tdc_brd);
      }
      tdcmt1 = fFndFeeMap->GetTofMTSlb(tof_tdc_brd,tof_tdc_chn);
      tdcslb1 = fFndFeeMap->GetTofTdcSlb(tof_tdc_brd,tof_tdc_chn);
      is_side_p = (Short_t) fFndFeeMap->GetTofTdcSide(tof_tdc_brd,tof_tdc_chn); 
      if(deb_tof > 2) {
        Printf("TFndRdt::FillTofTdcHits --------> conv: %d ; tdcslb1 = %d",k,tdcslb1);
        Printf("TFndRdt::FillTofTdcHits --------> conv: %d ; tdcmt1 = %d",k,tdcmt1);
        Printf("TFndRdt::FillTofTdcHits --------> conv: %d ; is_side_p = %d",k,is_side_p);
      }
      if(tdcslb1 == 0 && tdcmt1 == 0){
        if(deb_tof && fCurRunType != RT_PEDE) Warning("FillTofTdcHits","Event %d: Tdc board: %d, ch: %d not mapped inside DB",fRawEvent[2],tof_tdc_brd,tof_tdc_chn);
        continue;
      }
      // the raw-datum reading is completed: now building (or updating) the hit
      WhichMod = 0;
      //is_new_hit = kFALSE;
      if     (tdcslb1 != 0 && tdcmt1 == 0) WhichMod = (WhichMod & (0x1));
      else if(tdcslb1 == 0 && tdcmt1 != 0) WhichMod = (WhichMod | (1<<1));
      else{
        Error("FillTofTdcHits","Ambiguous module selection");
        //gApplication->Terminate(); // this line has been commented on June 12, 2007
        continue; // this line has been added on June 12, 2007
      }
      
      if     (tdcslb1 > 300) { WhichMod = (WhichMod | (0x1)); tdcslb1 -= 300; }
      else if( tdcmt1 > 300) { WhichMod = (WhichMod | (0x1)); tdcmt1 -= 300; }
      //        else WhichMod = (WhichMod & (0x2));

      TFndHTof *htof;
      if((WhichMod & (0x2)) == 0) htof = TFndRun::fgFinHdt->Find_Add_TofHit(tdcslb1,kTRUE);
      else htof = TFndRun::fgFinHdt->Find_Add_TofHit(tdcmt1,kTRUE);

      switch(WhichMod){
      case 0: htof->SetLowTdc(tof_tdc_cnt,(E_Fnd_Side)is_side_p);     break;
      case 1: htof->SetHighTdc(tof_tdc_cnt,(E_Fnd_Side)is_side_p); break;
      case 2: htof->SetLowMeanTimer(tof_tdc_cnt);         break;
      case 3: htof->SetHighMeanTimer(tof_tdc_cnt);     break;
      default: 
        Error("FillTofTdcHits","Don't know what to do :(");
        gApplication->Terminate();
      }

    }
  }

  if(deb_tof) Printf("TFndRdt::FillTofTdcHits ---> exiting method");
} 

//____________________________________
void TFndRdt::FillLmdHits() {

  UInt_t *det = GetDetector(FIN_RDT_Eqp_Lmd);  
  if (det==NULL){
    if(fDebugLev > 0) Warning("FillLmdHits","detector not in the run (null pointer)");
    return;
  }
  
  FillLmdAdcHits();
  FillLmdTdcHits();
}

//____________________________________
void TFndRdt::FillLmdAdcHits() {
  // Rewritten (September 2006)
  
  UInt_t deb_lmd = (fDebugLev >> ((Int_t)(D_LMD)*4)) & 0xF; // get sil digit

  if(deb_lmd) Printf("TFndRdt::FillLmdAdcHits ---> ADC equipment");
  UInt_t *equ = GetEquipment( FIN_RDT_Eqp_Lmd, FIN_EQ_CAEN_VN1485 );
  if(!equ){
    Error("FillLmdAdcHits","Pointer to the required equipment is NULL");
    return;
  }
  UInt_t *ladcptr=equ+1;
  if(!ladcptr){
    Error("FillLmdAdcHits","Pointer to the adc structure is NULL");    
    return;
  }
  
  if(equ[0] <= 0 || equ[0] > K_MAX_EQP_LEN) {
    Error("FillLmdAdcHits","adc length not accepted: value= %u",equ[0]);
    return;
  }
  Int_t ladclen=(Int_t)(equ[0]-1);
  if(deb_lmd) Printf("TFndRdt::FillLmdAdcHits ---> ADC length: %u",ladclen);
  if(ladclen == 0) return;
  // if you are here ladclen is a valid number  

  //  equ = find_equ(ev,LMD,EQ06);
  Int_t conv_counter = 0;
  if (equ) for (int k=1,h=0; k<equ[0]; k++,h--) {
    if (h==0) {
      h = (equ[k]&0x7FF) + 1;  k++;
      if(deb_lmd) Printf( "TFndRdt::FillLmdAdcHits ---> %d conversions",h-1);
      conv_counter=0;
    }
    if (h==1) continue;
    
    int mod = ((equ[k]>>23) & 0x1F); //lmd_adc_brd
    int cha = (equ[k]>>16) & 0x3F; // lmd_adc_chn
    float val = (float)(equ[k] & 0xFFF); // lmd_adc_cnt

    Int_t lmd_adc_cnt = (Int_t)val;
    Int_t lmd_adc_chn = cha;
    Int_t lmd_adc_brd = mod;
    if(deb_lmd > 1) {
      Printf("TFndRdt::FillLmdAdcHits ---> conv: %d ; EvtBuf Ch-data = 0x%x",conv_counter,(Int_t)equ[k]);
      Printf("TFndRdt::FillLmdAdcHits -----> conv: %d ; lmd_adc_cnt = %d",conv_counter,lmd_adc_cnt);
      Printf("TFndRdt::FillLmdAdcHits -----> conv: %d ; lmd_adc_chn = %d",conv_counter,lmd_adc_chn);
      Printf("TFndRdt::FillLmdAdcHits -----> conv: %d ; lmd_adc_brd = %d",conv_counter,lmd_adc_brd);
    }
    
    Int_t adcdch1 = 0;
    Int_t adcwir1 = 0;
    Short_t is_side_p = -1;
    if(!fFndFeeMap->IsThere()) continue;
    //    if(fFndFeeMap->IsThere()){
    adcdch1 = fFndFeeMap->GetLmdAdcDch(lmd_adc_brd,lmd_adc_chn);
    if(adcdch1<=0) continue;
    adcwir1 = fFndFeeMap->GetLmdAdcWire(lmd_adc_brd,lmd_adc_chn);
    is_side_p = (Short_t) fFndFeeMap->GetLmdAdcSide(lmd_adc_brd,lmd_adc_chn);
    if(deb_lmd > 2) {
      Printf("TFndRdt::FillLmdAdcHits --------> conv: %d ; adcdch1 = %d",conv_counter,adcdch1);
      Printf("TFndRdt::FillLmdAdcHits --------> conv: %d ; adcwir1 = %d",conv_counter,adcwir1);
      Printf("TFndRdt::FillLmdAdcHits --------> conv: %d ; is_side_p = %d",conv_counter,is_side_p);
    }
    conv_counter++;
    
    TFndHLmd *check_hit; // can be used for debuggin purposes
    check_hit = TFndRun::fgFinHdt->Find_Add_LmdHit(TFndDB::Lmd_ChannelToDBNumbering(adcdch1,adcwir1),kTRUE);
    check_hit->SetAdc(lmd_adc_cnt,(E_Fnd_Side)is_side_p);
    
    if(deb_lmd > 3) check_hit->PrintHit(1);
    
  }
  
  if(deb_lmd) Printf("TFndRdt::FillLmdAdcHits ---> exiting method");
}

//____________________________________
void TFndRdt::FillLmdTdcHits() {
  // Rewritten (September 2006)
  
  UInt_t deb_lmd = (fDebugLev >> ((Int_t)(D_LMD)*4)) & 0xF; // get sil digit
  Int_t run_time = fndrun->GetRunTime();
  
  //  TDC equipment
  E_FIN_RDT_EqpID tdceqpnum = FIN_EQ_LECROY_1277;
  if(run_time > Fee_Lmd_NewTdcsTime) tdceqpnum = FIN_EQ_CAEN_673A;
  if(deb_lmd) Printf("TFndRdt::FillLmdTdcHits ---> TDC equipment");
  
  UInt_t *equ = GetEquipment( FIN_RDT_Eqp_Lmd, tdceqpnum );
  if(!equ){
    if( fCurRunType != (Int_t)(RT_PEDE) )
      Error("FillLmdTdcHits","Pointer to the required equipment is NULL");
    return;
  }

  UInt_t *ltdcptr=equ+1;
  if(!ltdcptr){
    Error("FillLmdTdcHits","Pointer to the tdc structure is NULL");    
    return;
  }

  if(equ[0] <= 0 || equ[0] > K_MAX_EQP_LEN) {
    Error("FillLmdTdcHits","tdc length not accepted: value= %u",equ[0]);
    return;
  }
  UInt_t ltdclen=equ[0]-1;
  if(deb_lmd) Printf("TFndRdt::FillLmdTdcHits ---> TDC length: %u",ltdclen);
  if(ltdclen == 0) return;
  // if you are here ltdclen is a valid number  
  
  //-------------------------------------------------------------
  //-----------> (LMD, eqp 10) vme tdc 6U CAEN VN673A  <----------
  //-------------------------------------------------------------
  //  equ = find_equ(ev,LMD,EQ10);
  Int_t iboard_offset = 0;
  int h=0;
  int k=1;
  if (equ) while ( k<equ[0]-1) {
    h = (equ[k]&0xFFFF); // number of conversions
    if(deb_lmd) Printf( "TFndRdt::FillLmdTdcHits ---> %d conversions",h);
    int lmd_tdc_brd = ((equ[k]>>26) & 0xF); //lmd_tdc_brd
    k++;
    for(int i=0;i<h;i++,k++){
      int isval = (equ[k]>>31)&0x1; // isvalid
      if(isval==0){
        int lmd_tdc_chn = (equ[k]>>18) & 0x3F; // lmd_tdc_chn
        Int_t lmd_tdc_cnt = (equ[k] & 0xFFFF); // (don't know)
        //      float lmd_tdc_cnt = (float)(equ[k] & 0xFFFF); // (don't know)
        lmd_tdc_brd = ((equ[k]>>26) & 0xF); // lmd_tdc_brd

        // --- comparison with read_lib variables
        //      Int_t lmd_tdc_cnt = (Int_t)val;
        //      Int_t lmd_tdc_chn = cha; 
        //      Int_t lmd_tdc_brd = mod;
        if(deb_lmd > 1) {
          Printf("TFndRdt::FillLmdTdcHits ---> conv: %d ; EvtBuf Ch-data = 0x%x",k,(Int_t)equ[k]);
          Printf("TFndRdt::FillLmdTdcHits -----> conv: %d ; lmd_tdc_cnt = %d",k,lmd_tdc_cnt);
          Printf("TFndRdt::FillLmdTdcHits -----> conv: %d ; lmd_tdc_chn = %d",k,lmd_tdc_chn);
          Printf("TFndRdt::FillLmdTdcHits -----> conv: %d ; lmd_tdc_brd = %d",k,lmd_tdc_brd);
        }       
        Int_t tdcdch1 = 0;
        Int_t tdcwir1 = 0;
        Int_t is_side_p  = -1;
        if(!fFndFeeMap->IsThere() || isval != 0) continue;
          tdcdch1 = fFndFeeMap->GetLmdTdcDch(lmd_tdc_brd-iboard_offset,lmd_tdc_chn);
          if(tdcdch1<=0) continue;
          tdcwir1 = fFndFeeMap->GetLmdTdcWire(lmd_tdc_brd-iboard_offset,lmd_tdc_chn);
          is_side_p = fFndFeeMap->GetLmdTdcSide(lmd_tdc_brd-iboard_offset,lmd_tdc_chn); 

          if(deb_lmd > 2) {
            Printf("TFndRdt::FillLmdTdcHits --------> conv: %d ; tdcdch1 = %d",k,tdcdch1);
            Printf("TFndRdt::FillLmdTdcHits --------> conv: %d ; tdcwir1 = %d",k,tdcwir1);
            Printf("TFndRdt::FillLmdTdcHits --------> conv: %d ; is_side_p = %d",k,is_side_p);
          }
          
          TFndHLmd *check_hit; // can be used for debuggin purposes
          check_hit = TFndRun::fgFinHdt->Find_Add_LmdHit(TFndDB::Lmd_ChannelToDBNumbering(tdcdch1,tdcwir1),kTRUE);
          check_hit->SetTdc(lmd_tdc_cnt,(E_Fnd_Side)is_side_p);

          if(deb_lmd > 3) check_hit->PrintHit(1);

      }
    }
  }
  
  if(deb_lmd) Printf("TFndRdt::FillLmdTdcHits ---> exiting method");
} 

//____________________________________
void TFndRdt::FillStbHits() {
  
  UInt_t *det = GetDetector(FIN_RDT_Eqp_Stb);  
  if (det==NULL){
    if(fDebugLev > 0) Warning("FillStbHits","detector not in the run (null pointer)");
    return;
  }

  UInt_t deb_stb = (fDebugLev >> ((Int_t)(D_STB)*4)) & 0xF; // get tof digit
  if(deb_stb) Printf("TFndRdt::FillStbHits ---> TDC equipment");
  
  UInt_t *equ = GetEquipment( FIN_RDT_Eqp_Stb, FIN_EQ_LECROY_1277 );
  if(!equ){
    Error("FillStbHits","Pointer to the required equipment is NULL");
    return;
  }
  UInt_t *ltdcptr = equ+1;
  if(!ltdcptr){
    Error("FillStbHits","Pointer to the tdc structure is NULL");    
    return;
  }

  if(equ[0] <= 0 || equ[0] > K_MAX_EQP_LEN) {
    if(deb_stb) Printf("TFndRdt::FillStbTdcHits ---> exiting method (tdc length = %u)",equ[0]);
    return;
  }
  UInt_t ltdclen = equ[0]-1;
  if(deb_stb) Printf("TFndRdt::FillStbHits ---> TDC length: %u",ltdclen);
  if(ltdclen == 0) return;
  // if you are here ltdclen is a valid number  
 
  

  
  
  
  Int_t stb_tdc_cnt;
  Int_t stb_tdc_chn; 
  Int_t stb_tdc_brd;
  Int_t i=0;

  // UInt_t *end = ltdcptr + (*ltdcptr); TEST
  // while(ltdcptr < end) { // TEST
  while(i < (Int_t) ltdclen-1) { 
    //            if(i>0) { ltdcptr++; i++; } // BUG (infinite loop!)
    Int_t n_conv = (*ltdcptr)&0xFFFFFF;
    Int_t n_cage = ((*ltdcptr)>>0x18)&0xF;
    ltdcptr++; i++; // Diego and Giuseppe bugfix (moved to this line by D. Faso)
    if(deb_stb) Printf( "TFndRdt::FillStbTdcHits ---> %d conversions",n_conv);
    for(Int_t k=0;k<n_conv;k++) {
      stb_tdc_cnt = (Int_t) (*ltdcptr)&0xFFFF;
      stb_tdc_chn = (Int_t) ((*ltdcptr)>>0x11)&0x7F;
      stb_tdc_brd = (Int_t) ((*ltdcptr)>>0x1B)&0x1F;
      i++;
      ltdcptr++;
      if(stb_tdc_brd < 6 || stb_tdc_brd > 19){
        Warning("FillStbHits","board %d ",stb_tdc_brd); 
        continue;
      }      
      if(stb_tdc_chn < 0 || stb_tdc_chn > 95){
        Warning("FillStbHits","channel %d",stb_tdc_chn);
        continue;        
      } 
      if(deb_stb > 1) {
        Printf("TFndRdt::FillStbHits ---> conv: %d ; EvtBuf Ch-data = 0x%x",k,(UInt_t) (*ltdcptr));
        Printf("TFndRdt::FillStbHits -----> conv: %d ; stb_tdc_cnt = %d",k,stb_tdc_cnt);
        Printf("TFndRdt::FillStbHits -----> conv: %d ; stb_tdc_chn = %d",k,stb_tdc_chn);
        Printf("TFndRdt::FillStbHits -----> conv: %d ; stb_tdc_brd = %d",k,stb_tdc_brd);
      }
      // map stb tdc channel to stb wire
        
      Int_t crown = 0;
      Int_t tube  = 0;
      Int_t ppanel = 0;
      if(fFndFeeMap->IsThere()) {
        crown  = fFndFeeMap->GetStbCrown(n_cage,stb_tdc_brd,stb_tdc_chn);
        tube   = fFndFeeMap->GetStbWire(n_cage,stb_tdc_brd,stb_tdc_chn);
        ppanel = fFndFeeMap->GetStbPatchPanel(n_cage,stb_tdc_brd,stb_tdc_chn);
      }
      if(deb_stb > 2) {
        Printf("TFndRdt::FillStbHits --------> conv: %d ; crown   = %d",k,crown);
        Printf("TFndRdt::FillStbHits --------> conv: %d ; tube    = %d",k,tube);
        Printf("TFndRdt::FillStbHits --------> conv: %d ; p-panel = %d",k,ppanel);
      }
        
      if(crown < 1 || crown > 6){
        // Printf("TFndRdt::FillStbHits WARNING: crown %d ( skipping hit )",crown);
        continue;
      }
      if(tube < 1 || tube > 404){
        Printf("TFndRdt::FillStbHits WARNING: tube %d ( skipping hit )",tube);
        continue;
      }
        
      TFndHStb *hs = TFndRun::fgFinHdt->Find_Add_StbHit(TFndDB::Stb_ChannelToDBNumbering(crown,tube),kTRUE);
      hs->SetTdc(stb_tdc_cnt);
      hs->SetPatchPanel(ppanel);
      //        Printf("crown %d - tube %d - channel %d ===> tdc value: %d ; PPan: %d",crown, tube, TFndDB::Stb_ChannelToDBNumbering(crown,tube),stb_tdc_chn,ppanel);
      //        fCurHdtEv->AddStbHit(crown,tube,ppanel,stb_tdc_cnt);
      //        n_stb_hit++;
    }
  }

  if(deb_stb) Printf("TFndRdt::FillStbHits ---> exiting method");
}

---