TOF/TFndHTof.cxx

// @(#)fROOT/TOF:$Name:  $:$Id: TFndHTof.cxx,v 1.26 2007/10/16 12:03:44 Diego_Faso Exp $
// Revision Author: Diego Faso <mailto:faso@to.infn.it>, 2005/06/24
// Original Author: Piergiorgio Cerello <mailto:cerello@to.infn.it>

//                                                       //
//               TFndHTof                                //
//                                                       //
//  Class for the TOF HDT description                    //
//                                                       //
// Numbering:                                            //
//      1- 12: TOFINO low-threshold CFD->mean-timer TDC  //
//    300-312: TOFINO high-threshold CFD->mean-timer TDC //
//    100-172: TOFONE  CFD->mean-timer TDC               //
//                                                //

#include <Riostream.h>

#include "TFndRun.h"
#include "TFndHTof.h"
#include "TFndGenInfo.h"
#include "TMath.h"

ClassImp(TFndHTof)

//______________________________________________
TFndHTof::TFndHTof(const Int_t &channel):
  TFndHit(channel),
  fLayer(),fSlab(),
  fAdc(),fLowTdc(),fLowMeanTimer(),fHighTdc(),fHighMeanTimer(),
  fCalibAdc(),
  fCalibLowTdc(),fCalibLowMeanTimer(),
  fCalibHighTdc(),fCalibHighMeanTimer(),
  fEnergyDep(),
  fBothAdc(),fBothLowTdc(),fBothHighTdc(),
  fOverChargeVal()
{
  Init();
  TFndDB::Tof_ChNum_To_DetChan(fChannel,fLayer,fSlab);
}

//______________________________________________
TFndHTof::~TFndHTof() {
  //
}

//_______________________________
void TFndHTof::Init(){
  // initialize all data-members to defaults

  for(Int_t i=0;i<2;i++){
    fAdc[i] = -1;
    fLowTdc[i] = -1;
    fHighTdc[i] = -1;
    //
    fCalibAdc[i] = -1;
    fCalibLowTdc[i] = -1;
    fCalibHighTdc[i] = -1;
  }
  fLowMeanTimer = -1;
  fHighMeanTimer = -1;
  fCalibLowMeanTimer = -1;
  fCalibHighMeanTimer = -1;
  //
  fBothAdc = -1;
  fBothLowTdc = -1;
  fBothHighTdc = -1;
  fOverChargeVal = 0;
}

//_______________________________
void TFndHTof::EvalHit(){
  // evaluate all hit attributes
  // (get info from DB (TFndDB) when needed)
  
  // --- "both-ADC/TDC" flags
  fBothAdc = E_HIT_NO_CH;
  if(fAdc[E_FIN_SIDE_P] >0  && fAdc[E_FIN_SIDE_E] >0)  fBothAdc = E_HIT_BOTH_CH;
  if(fAdc[E_FIN_SIDE_P] <=0 && fAdc[E_FIN_SIDE_E] >0)  fBothAdc = E_HIT_E_CH;
  if(fAdc[E_FIN_SIDE_P] >0  && fAdc[E_FIN_SIDE_E] <=0) fBothAdc = E_HIT_P_CH;
  
  fBothLowTdc = E_HIT_NO_CH;
  if(fLowTdc[E_FIN_SIDE_P] >0  && fLowTdc[E_FIN_SIDE_E] >0)  fBothLowTdc = E_HIT_BOTH_CH;
  if(fLowTdc[E_FIN_SIDE_P] <=0 && fLowTdc[E_FIN_SIDE_E] >0)  fBothLowTdc = E_HIT_E_CH;
  if(fLowTdc[E_FIN_SIDE_P] >0  && fLowTdc[E_FIN_SIDE_E] <=0) fBothLowTdc = E_HIT_P_CH;
  
  fBothHighTdc = E_HIT_NO_CH;
  if(fHighTdc[E_FIN_SIDE_P] >0  && fHighTdc[E_FIN_SIDE_E] >0)  fBothHighTdc = E_HIT_BOTH_CH;
  if(fHighTdc[E_FIN_SIDE_P] <=0 && fHighTdc[E_FIN_SIDE_E] >0)  fBothHighTdc = E_HIT_E_CH;
  if(fHighTdc[E_FIN_SIDE_P] >0  && fHighTdc[E_FIN_SIDE_E] <=0) fBothHighTdc = E_HIT_P_CH;
 
  fPosLRS[0] = 0;
  fPosLRS[1] = 0;
  fPosLRS[2] = 0;


  TFndFeeMap *fDB = fndrun->GetFeeMap();
  // ---
  for(Int_t sid=0;sid<2;sid++){ // loop on the two sides
    if(fAdc[sid] == -1) continue;
    fCalibAdc[sid] = fAdc[sid] - fDB->GetTofCal_Q0(fLayer,fSlab,sid);
    fCalibAdc[sid] = fCalibAdc[sid] * fDB->GetTofCal_Q1(fLayer,fSlab,sid);
  }

  for(Int_t sid=0;sid<2;sid++){ // loop on the two sides
    if(fLowTdc[sid] == -1) continue;
    fCalibLowTdc[sid] = fDB->GetTofCal_T0_LowTh(fLayer,fSlab,sid) - fLowTdc[sid] ;
    fCalibLowTdc[sid] = fCalibLowTdc[sid] * fDB->GetTofCal_T1_LowTh(fLayer,fSlab,sid);
  }
  if(fLowMeanTimer != -1){
    fCalibLowMeanTimer = fDB->GetTofCal_T0_LowTh(fLayer,fSlab,2) - fLowMeanTimer ;
    fCalibLowMeanTimer = fCalibLowMeanTimer * fDB->GetTofCal_T1_LowTh(fLayer,fSlab,2);
  }
  
  for(Int_t sid=0;sid<2;sid++){ // loop on the two sides
    if(fHighTdc[sid] == -1) continue;
    fCalibHighTdc[sid] = fDB->GetTofCal_T0_HighTh(fLayer,fSlab,sid) - fHighTdc[sid] ;
    fCalibHighTdc[sid] = fCalibHighTdc[sid] * fDB->GetTofCal_T1_HighTh(fLayer,fSlab,sid);
  }
  if(fHighMeanTimer != -1){
    fCalibHighMeanTimer = fDB->GetTofCal_T0_HighTh(fLayer,fSlab,2) - fHighMeanTimer ;
    fCalibHighMeanTimer = fCalibHighMeanTimer * fDB->GetTofCal_T1_HighTh(fLayer,fSlab,2);
  }
  
  if(fBothAdc == E_HIT_BOTH_CH){ // charge evaluation
    if( (fCalibAdc[E_FIN_SIDE_E] * fCalibAdc[E_FIN_SIDE_P]) < 0){
      // Warning("EvalHit","Negative charge in TOF hit"); // [left side of pedestal]
      fDB = 0; // owned by TFndRun
      return;
    }
    fEnergyDep = TMath::Sqrt(fCalibAdc[E_FIN_SIDE_E] * fCalibAdc[E_FIN_SIDE_P]);
    // ---
  }
  
  // zeta evaluation
  Int_t dtak = GetDataTakingFromTime(fndrun->GetRunTime());

  cout << "===========> " << dtak << endl;

  if(fLayer == static_cast<Int_t>(E_FIN_INNER_LAYER)){ // TOFINO
    fPosLRS[2]= -999;
    if(fBothAdc == E_HIT_BOTH_CH){
      switch(dtak){
      case 1:
        fPosLRS[2] = TofinoZetaFromCharge(dtak,
                                          (Double_t) ( fAdc[static_cast<Int_t>(E_FIN_SIDE_E)] ),
                                          (Double_t) ( fAdc[static_cast<Int_t>(E_FIN_SIDE_P)] )
                                          );
        break;
      case 2:
        Printf("Data-taking -------: %d",dtak);
        if(fCalibAdc[static_cast<Int_t>(E_FIN_SIDE_E)] <=0 || fCalibAdc[static_cast<Int_t>(E_FIN_SIDE_P)] <=0)
          break;
        fPosLRS[2] = TofinoZetaFromCharge(dtak,
                                          (Double_t) ( fCalibAdc[static_cast<Int_t>(E_FIN_SIDE_E)] ),
                                          (Double_t) ( fCalibAdc[static_cast<Int_t>(E_FIN_SIDE_P)] )
                                          );
        break;
      default:
        break;
      }
      
    }
  }
  else{ // TOFONE
    if(fBothHighTdc == E_HIT_BOTH_CH || fBothLowTdc == E_HIT_BOTH_CH){
      fPosLRS[2] = TofoneZetaFromTime(dtak,
                                      (Double_t)(fCalibLowTdc[E_FIN_SIDE_E] ),
                                      (Double_t)(fCalibLowTdc[E_FIN_SIDE_P] )
                                      );
      // fPosLRS[2] = (Double_t) ( (  tcp -  tce ) / (2 ) * TofZetaGeoAdjust(fLayer)); // old method
    }
  }
  
  gFndGeom->RefSys_TofSlabToMRS(fChannel,fPosLRS,fPosMRS);
  // ---
  fDB = 0; // owned by TFndRun

  if(fLayer == E_FIN_INNER_LAYER)
    fOverChargeVal  = fEnergyDep - TFndHdt::GetTofinoChargeCut(fSlab,fndrun->GetRunTime());

  //  PrintHit(3); // this line can be useful for debug  
}

//_______________________________
void TFndHTof::PrintHit(Int_t depth)
{
  // to be completed

  if( depth <=0 ) return;

  TString msg = "";
  TString linemsg = " --- --- --- --- ---\n";
  msg+=linemsg;
  
  linemsg.Form("Tof Channel: %d\n",fChannel); msg+=linemsg;
  
  if(depth>1){
    linemsg.Form(" ---> Adc E: %d\n",fAdc[E_FIN_SIDE_E]); msg+=linemsg;
    linemsg.Form(" ---> Adc P: %d\n",fAdc[E_FIN_SIDE_P]); msg+=linemsg;
    if(depth > 2){
      linemsg.Form(" ------> Both-Adc flag: %d\n",fBothAdc); msg+=linemsg;
    }
    linemsg.Form(" ---> Tdc E (low-th): %d\n",fLowTdc[E_FIN_SIDE_E]); msg+=linemsg;
    linemsg.Form(" ---> Tdc P (low-th): %d\n",fLowTdc[E_FIN_SIDE_P]); msg+=linemsg;
    linemsg.Form(" ---> MeanT (low-th): %d\n",fLowMeanTimer); msg+=linemsg;
    if(depth > 2){
      linemsg.Form(" ------> Both-Tdc (low-th) flag: %d\n",fBothLowTdc); msg+=linemsg;
    }
    linemsg.Form(" ---> Tdc E (high-th): %d\n",fHighTdc[E_FIN_SIDE_E]); msg+=linemsg;
    linemsg.Form(" ---> Tdc P (high-th): %d\n",fHighTdc[E_FIN_SIDE_P]); msg+=linemsg;
    linemsg.Form(" ---> MeanT (high-th): %d\n",fHighMeanTimer); msg+=linemsg;
    linemsg.Form(" ---> Over chrg phel.: %.2f\n",fOverChargeVal); msg+=linemsg;
    if(depth > 2){
      linemsg.Form(" ------> Both-Tdc (high-th) flag: %d\n",fBothHighTdc); msg+=linemsg;
      linemsg = " --- --- ---"; msg+=linemsg;
      linemsg.Form(" ------> Calib. Adc E: %.2f\n",fCalibAdc[E_FIN_SIDE_E]); msg+=linemsg;
      linemsg.Form(" ------> Calib. Adc P: %.2f\n",fCalibAdc[E_FIN_SIDE_P]); msg+=linemsg;
      linemsg.Form(" ------> Calib. Tdc E (low-th): %.2f\n",fCalibLowTdc[E_FIN_SIDE_E]); msg+=linemsg;
      linemsg.Form(" ------> Calib. Tdc P (low-th): %.2f\n",fCalibLowTdc[E_FIN_SIDE_P]); msg+=linemsg;
      linemsg.Form(" ------> Calib. MeanT (low-th): %.2f\n",fCalibLowMeanTimer); msg+=linemsg;
      linemsg.Form(" ------> Calib. Tdc E (high-th): %.2f\n",fCalibHighTdc[E_FIN_SIDE_E]); msg+=linemsg;
      linemsg.Form(" ------> Calib. Tdc P (high-th): %.2f\n",fCalibHighTdc[E_FIN_SIDE_P]); msg+=linemsg;
      linemsg.Form(" ------> Calib. MeanT (high-th): %.2f\n",fCalibHighMeanTimer); msg+=linemsg;
      linemsg.Form(" ------> Energy dep. (ph-el): %.2f\n",fEnergyDep); msg+=linemsg;
    }
  }
  
  // ---
  msg.Resize(msg.Sizeof()-2);
  Printf("%s",msg.Data());

  if(depth>2) PrintPosition(0);
  // ---
  
}

---