STEER/TFndHdt.cxx

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

//                               TFndHdt                               //
//                                                                     //
// This class gives the Description of the Hit Data Tape event:        //
// it contains a set of pointers to Arrays of hit objects for          //
// different detectors, a pointer to a Header object, a pointer        //
//                                                                     //
//      to the Trigger object and a set of integers giving             //
// the number of hits for each detector and the total number of hits   //
//                                                                     //

#include "TFndHdt.h"
//#include "TFndRunConfiguration.h"
//#include "TFile.h"
//#include "TObjectTable.h"

ClassImp(TFndHdt)

TClonesArray *TFndHdt::fgHTof = 0;
TClonesArray *TFndHdt::fgHSilCluster = 0;
TClonesArray *TFndHdt::fgHLmd = 0;
TClonesArray *TFndHdt::fgHStb = 0;

//___________________________________________
TFndHdt::TFndHdt()
  :fRunNumber(),fEvtNum(),
   fNoiseLevel(-999)
   
{
  SetSilComMod_meanmaxcount_zero();

  fGts = new TFndTrig();
  if (!fgHTof) fgHTof = new TClonesArray("TFndHTof",84);
  fTofHits = fgHTof;
  
  if (!fgHSilCluster) fgHSilCluster = new TClonesArray("TFndHSilCluster",100);
  fSilClusters = fgHSilCluster;
  
  if (!fgHLmd) fgHLmd = new TClonesArray("TFndHLmd",272);
  fLmdHits = fgHLmd;
  
  if (!fgHStb) fgHStb = new TClonesArray("TFndHStb",2404);
  fStbHits = fgHStb;
  
}

//___________________________________________
TFndHdt::~TFndHdt()
{ 
  ClearArrays();
  Reset();
  delete fGts; fGts = 0;
  //  delete fTofHits; fTofHits = 0;

  //   delete fGts; fGts = 0;
  //   delete fgHTof; fgHTof = 0;
  //   delete fgHSilCluster; fgHSilCluster = 0;
  //   delete fgHLmd; fgHLmd = 0;
  //   delete fgHStb; fgHStb = 0;
} 

//___________________________________________
void TFndHdt::ClearArrays(){

  fRunNumber = 0;
  fEvtNum = 0;
  fNoiseLevel = -999;
  //
  fGts->Reset();
  // ---
  fTofHits->Clear();
  //
  SetSilComMod_meanmaxcount_zero();
  fSilClusters->Clear();
  //
  fLmdHits->Clear();
  //
  fStbHits->Clear();
  
  //  TCollection::EmptyGarbageCollection(); // to be tested
}

//___________________________________________
void TFndHdt::Reset(){

  fRunNumber = 0;
  fEvtNum = 0;
  fNoiseLevel = -999;
  //
  fGts->Reset();
  // ---
  fTofHits->Delete();
  //
  SetSilComMod_meanmaxcount_zero();
  fSilClusters->Delete();
  //
  fLmdHits->Delete();
  //
  fStbHits->Delete();
  
  //  TCollection::EmptyGarbageCollection(); // to be tested
}

//___________________________________________
TFndHTof *TFndHdt::Find_Add_TofHit(Int_t channel,Bool_t add_if_missing){
  
  Int_t last_id = fTofHits->GetEntries();
  for(Int_t i=0;i<last_id;i++)
    if( ((TFndHTof*)fTofHits->At(i))->GetChannel() == channel){
      //      Printf("TFndHdt::Find_Add_TofHit ---> Hit found at position %d (channel %d)",i,channel);
      return ((TFndHTof*)fTofHits->At(i));
    }
  
  if(!add_if_missing){
    Info("Find_Add_TofHit","No hit found for channel %d",channel);
    return 0;
  }
  
  TClonesArray &tof_hits = *fTofHits;
  TFndHTof *th = new(tof_hits[last_id]) TFndHTof(channel);
  //  Printf("TFndHdt::Find_Add_TofHit ---> Hit added at position %d (channel %d)",last_id,channel);
  return th;
  
}

//___________________________________________
TFndHSilCluster *TFndHdt::Add_SilCluster(Int_t layer){
  // the "Find" step is dummy (kept for compatibility of method names)
  // ...still thinking if s SilCluster can be univocally identified

  Int_t last_id = fSilClusters->GetEntries();
  
  TClonesArray &sil_hits = *fSilClusters;
  TFndHSilCluster *sch = new(sil_hits[last_id]) TFndHSilCluster(layer);
  //  Printf("TFndHdt::Find_Add_SilCluster ---> Hit added at position %d (channel %d)",last_id,channel);
  return sch;
  
}

//___________________________________________
TFndHLmd *TFndHdt::Find_Add_LmdHit(Int_t channel,Bool_t add_if_missing){
  
  Int_t last_id = fLmdHits->GetEntries();
  for(Int_t i=0;i<last_id;i++)
    if( ((TFndHLmd*)fLmdHits->At(i))->GetChannel() == channel){
      //      Printf("TFndHdt::Find_Add_LmdHit ---> Hit found at position %d (channel %d)",i,channel);
      return ((TFndHLmd*)fLmdHits->At(i));
    }
  
  if(!add_if_missing){
    Info("Find_Add_LmdHit","No hit found for channel %d",channel);
    return 0;
  }
  
  TClonesArray &lmd_hits = *fLmdHits;
  TFndHLmd *lh = new(lmd_hits[last_id]) TFndHLmd(channel);
  //  Printf("TFndHdt::Find_Add_LmdHit ---> Hit added at position %d (channel %d)",last_id,channel);
  return lh;

  
}

//___________________________________________
TFndHStb *TFndHdt::Find_Add_StbHit(Int_t channel,Bool_t add_if_missing){
  
  Int_t last_id = fStbHits->GetEntries();
  for(Int_t i=0;i<last_id;i++)
    if( ((TFndHStb*) fStbHits->At(i))->GetChannel() == channel){
      if(add_if_missing) Warning("Find_Add_StbHit","Hit found at position %d (channel %d)",i,channel);
      return ((TFndHStb*) fStbHits->At(i));
    }
  
  if(!add_if_missing){
    Info("Find_Add_StbHit","No hit found for channel %d",channel);
    return 0;
  }
  TClonesArray &stb_hits = *fStbHits;
  TFndHStb *sh = new(stb_hits[last_id]) TFndHStb(channel);
  //  Printf("TFndHdt::Find_Add_StbHit ---> Hit added at position %d (channel %d)",last_id,channel);
  return sh;

}

//___________________________________________
void TFndHdt::EvalHits(){
  // eval hits positions, SIL clusters, calibrations, "both flags", etc...
  
  for(Int_t ic = 0 ; ic < fTofHits->GetEntries() ; ic++) ( (TFndHTof *)fTofHits->At(ic) )->EvalHit();
  for(Int_t ic = 0 ; ic < fSilClusters->GetEntries() ; ic++) ( (TFndHSilCluster *)fSilClusters->At(ic) )->EvalHit();  
  for(Int_t ic = 0 ; ic < fLmdHits->GetEntries() ; ic++) ( (TFndHLmd*) fLmdHits->At(ic) )->EvalHit();
  for(Int_t ic = 0 ; ic < fStbHits->GetEntries() ; ic++) ( (TFndHStb*) fStbHits->At(ic) )->EvalHit();
  
  EvalNoiseLevel(); 
}

//___________________________________________
void TFndHdt::EvalNoiseLevel(){
  // Event noise level evaluated looking at TOFINO hits
  //
  //                 //  -3: One slab only: event lost (rejected by charge cut + BtB)
  //                 //  -2: One slab only: event lost (rejected by charge cut)
  //                 //  -1: One slab only: event lost (trigger error)
  //                 //   0: MT-selection ( already BtB )
  //                 //   1: MT-selection + BtB
  //                 //   2: MT-selection + BtB + CHARGE cut
  //                 //   3: MT-selection + BtB + CHARGE cut + BtB
  //                 // 4-9: not used (free for further development)
  //                 //  10: Further selection needed (ISIM...)
  //  
  // NOTE: meaningful for Hype events only

  const Int_t nsl = K_N_TOFINO_SLABS; // just for convenience

  TFndHTof *tmptof = 0;

  Bool_t fIsHighMeanTime[nsl];
  Bool_t fIsLowMeanTime[nsl];
  Bool_t fIsHighAdc[nsl];
  
  // following arreys are used alternatively
  // during consecutive selection steps
  //    (they depend on each other)
  Bool_t fIsSelected_A[nsl]; // odd  selections
  Bool_t fIsSelected_B[nsl]; // even selections

  for(Int_t i=0; i<nsl; i++){
    fIsHighMeanTime[i] = kFALSE;
    fIsLowMeanTime[i]  = kFALSE;
    fIsHighAdc[i]      = kFALSE;
    //
    fIsSelected_A[i]   = kFALSE;
    fIsSelected_B[i]   = kFALSE;
  }

  // --- inspect all hits
  Int_t nhits = fTofHits->GetEntries();
  for(Int_t nh=0; nh<nhits; nh++){ // loop on TOF hits
    tmptof = ( (TFndHTof *)fTofHits->At(nh) );
    if(!tmptof){
      Error("EvalNoiseLevel","Maybe you have just found a BUG!!!");
      TerminateFroot();
    }
    Int_t lay = tmptof->GetLayer();
    Int_t slab = tmptof->GetSlab();
    if(lay != E_FIN_INNER_LAYER || slab < 1 || slab > nsl) continue;
    // tofino hits have been selected
    // ---
    if(tmptof->GetHighMeanTimer() > -1) fIsHighMeanTime[slab-1] = kTRUE;
    if(tmptof->GetLowMeanTimer() > -1) fIsLowMeanTime[slab-1] = kTRUE;
    
    //     Float_t chrg = tmptof->GetEnergyDep();
    //     if( chrg > K_EN_THR[slab-1]) fIsHighAdc[slab-1] = kTRUE;
    Float_t overchrg = tmptof->GetOverChargeValue();
    if( overchrg > 0 ) fIsHighAdc[slab-1] = kTRUE;
  } // hits loop completed
  
  // 
  // --- check obtained results
  //

  Int_t nsel = -1; // number of selected slabs (after every selection step)
  
  // --- first selection (mean-timer) (sel n.1 : A)
  nsel = 0;
  for(Int_t i=0; i<nsl; i++){
    if( fIsHighMeanTime[i] ){
      fIsSelected_A[i] = kTRUE;
      nsel++;
    }
    else fIsSelected_A[i] = kFALSE;
  }
  // ---
  if(nsel < 2){ 
    fNoiseLevel = -1;
    return;
  }  
  Bool_t isgood = kFALSE; // used before BtB selection
  if(nsel == 2){ 
    isgood = kTRUE;
  }
  // --- check trigger extended-btb (sel n.2 : B)
  for(Int_t i=0; i<nsl; i++) fIsSelected_B[i] = kFALSE;
  for(Int_t i=0; i<nsl; i++) {
    for(Int_t j=0; j<nsl; j++) {
      if(i!=j && fIsSelected_A[i] && fIsSelected_A[j] ) {
        if( CheckTofinoBtb(i,j)){
          fIsSelected_B[i] = kTRUE;
          fIsSelected_B[j] = kTRUE;
        }
      }
    }
  }
  //
  // --- 
  nsel = 0;
  for(Int_t i=0; i<K_N_TOFINO_SLABS; i++){
    if( fIsSelected_B[i] ) nsel++; 
  }
  // ---
  if( nsel == 2 ){
    fNoiseLevel = (isgood) ? 0 : 1;
    return;
  } 
  else if(nsel < 2){
    fNoiseLevel = -1;
    return;
  }
  // --- check charge  (sel n.3 : A)
  isgood = kFALSE;
  nsel = 0;
  for(Int_t i=0; i<nsl; i++) {
    if( fIsSelected_B[i] && fIsHighAdc[i] ){
      fIsSelected_A[i] = kTRUE;
      nsel++;
    }
    else  fIsSelected_A[i] = kFALSE;
  }
  // ---
  if(nsel < 2){
    fNoiseLevel = -2;
    return;
  }  
  if(nsel == 2){ 
    isgood = kTRUE;
  }
  // --- check trigger extended-btb (sel n.4 : B)
  for(Int_t i=0; i<nsl; i++) fIsSelected_B[i] = kFALSE;
  for(Int_t i=0; i<nsl; i++) {
    for(Int_t j=0; j<nsl; j++) {
      if( i !=j && fIsSelected_A[i] && fIsSelected_A[j] ) {
        if( CheckTofinoBtb(i,j)){
          fIsSelected_B[i] = kTRUE;
          fIsSelected_B[j] = kTRUE;
        }
      }
    }
  }
  //
  // --- 
  nsel = 0;
  for(Int_t i=0; i<K_N_TOFINO_SLABS; i++){
    if( fIsSelected_B[i] ) nsel++; 
  }
  // ---
  if( nsel == 2 ){
    fNoiseLevel = (isgood) ? 2 : 3;
    return;
  } 
  else if(nsel < 2){
    fNoiseLevel = -3;
    return;
  }
  fNoiseLevel = 999;

  // ---
  tmptof = 0;
}

//___________________________________________
void TFndHdt::PrintHits(Int_t dpt_gts,Int_t dpt_tof,Int_t dpt_sil,Int_t dpt_lmd,Int_t dpt_stb) {
  // Print all hits (depending on the given depth-level)
  // Set "depth = -1" in order to disable printing for a specific detector
  
  TString msg = "";
  TString cline = "";
  
  cline.Form("\n\n TFndHdt::PrintHits - run %u , event %u\n",fRunNumber,fEvtNum); msg+=cline;
  cline.Form("  -> Print depth level for GTS is: %d \n",dpt_gts); msg+=cline;
  cline.Form("  -> Print depth level for TOF is: %d \n",dpt_tof); msg+=cline;
  cline.Form("  -> Print depth level for SIL is: %d \n",dpt_sil); msg+=cline;
  cline.Form("  -> Print depth level for LMD is: %d \n",dpt_lmd); msg+=cline;
  cline.Form("  -> Print depth level for STB is: %d \n",dpt_stb); msg+=cline;

  cline.Form("  -> Event evaluated noise level : %d \n",fNoiseLevel); msg+=cline;

  Printf(msg);
  
  PrintGts(dpt_gts);
  PrintTofHits(dpt_tof);
  if(dpt_sil > 3) PrintSilHits(dpt_sil);
  PrintSilClusters(dpt_sil);
  PrintLmdHits(dpt_lmd);
  PrintStbHits(dpt_stb);
  
  Printf("\n TFndHdt::PrintHits - All hits printed for run %u , event %u",fRunNumber,fEvtNum);
}

//___________________________________________
void TFndHdt::PrintGts(Int_t depth) {

  if(depth < 0) return;
  Printf("\nTFndHdt::PrintGts - event %u GTS content",fEvtNum);
  fGts->PrintTrigger(depth);

}

//___________________________________________
void TFndHdt::PrintTofHits(Int_t depth) {
  
  if(depth < 0) return;
  Int_t entries = fTofHits->GetEntries();
  Printf("\nTFndHdt::PrintTofHits - event %u ; number of TOF Hits: %d",fEvtNum,entries);
  for(Int_t ic=0;ic<entries; ic++) {
    ( (TFndHTof *)fTofHits->At(ic) )->PrintHit(depth);
  } 
  
}

//___________________________________________
void TFndHdt::PrintSilHits(Int_t depth){
  if(depth < 0) return;
  
  Printf("\nTFndHdt::PrintSilHits",fEvtNum);
  for(Int_t ch=0;ch<K_N_Sil_AdcCha;ch++){
    for(Int_t mod=0;mod<K_N_Sil_Modules;mod++){
      for(Int_t side=0;side<K_N_Sil_Sides;side++){
        Printf("  printing ch %d, mod %d, side %d",ch,mod,side);
        Printf("    -> Noise   : %d",fSilNoise[ch][mod][side]);
        Printf("    -> CM-mean : %d",fSilComMod_mean[ch][mod][side]);
        //      Printf("    -> CM-sigma: %d",fSilComMod_sigma[ch][mod][side]);
        //
      }
    }      
  }
  
}

//___________________________________________
void TFndHdt::PrintSilClusters(Int_t depth){

  if(depth < 0) return;
  
  Int_t entries = fSilClusters->GetEntries();
  Printf("\nTFndHdt::PrintSilClusters - event %u ; number of Sil-clusters: %d",fEvtNum,entries);
  for(Int_t ic=0;ic<entries; ic++) {
    TFndHSilCluster *hit = (TFndHSilCluster*) fSilClusters->At(ic); 
    hit->PrintHit(depth);
  } 
  

}

//___________________________________________
void TFndHdt::PrintLmdHits(Int_t depth) {
  
  if(depth < 0) return;
  Int_t entries = fLmdHits->GetEntries();
  Printf("\nTFndHdt::PrintLmdHits - event %u ; number of Drift Chambers Hits: %d",fEvtNum,entries);
  for(Int_t ic=0;ic<entries; ic++) {
    TFndHLmd *hit = (TFndHLmd*) fLmdHits->At(ic); 
    hit->PrintHit(depth);
  } 
  
}

//___________________________________________
void TFndHdt::PrintStbHits(Int_t depth) {

  if(depth < 0) return;

  Int_t entries = fStbHits->GetEntries();
  Printf("\nTFndHdt::PrintStbHits - event %u ; number of Straw Tubes Hits: %d",fEvtNum,entries);
  for(Int_t id=0;id<entries; id++) {
    TFndHStb *hit = (TFndHStb*) fStbHits->At(id); 
    hit->PrintHit(depth);
  } 
  
}

---