PREAN/TFndTrack.cxx

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

//                             TFndTrack                                //
//                                                          //
// Vertices are needed by tracks, so they are defined here: //
//  see TFndVertex                                          //
//                                                          //
//                                                          //
// The FINUDA event (from DST) is structure in this way:    //
//                                                          //
//  EVENT (info [ev-num,run-num,ev-time,trigger,...])       //
//    |                                                     //
//    +-> List of Tracks from K-                            //
//    +-> List of Tracks from K+                            //
//    +-> List of Vertices (if different from K_stop)       //
//                                                          //
// The link between tracks and vertices (not K-stop) is     //
//  made via the VertexID (track data-member):              //
//     fVertexID == -1 ===> track directly from K_stop      //
//     fVertexID >=  0 ===> track from other kind of vertex //
//                   fVertexID: entry of the vertices array //
//                                                          //
//                                                          //////////
//                                                                  //
// Relationship between tracks and vertex:                          //
//    vertex->tracks                                                //
//      (the vertex is always the starting point of related tracks) //
//                                                                  //
// Vertex PID is referred to the particle the track starts from.    //
//                                                                  //
//                                                          //////////
//                                                          //
// NOTE: (Sept 22, 2007)                                    //
//   The vertex implementation is still in progress:        //
//    Waiting for fidarc implementation to be completed...  //
//                                                          //

#include "TFndTrack.h"

ClassImp(TFndVertex)
  
//_______________________
TFndVertex::TFndVertex():
  fPID(),fPosition(),
  fDistFromPrimary(),fZtollerance()
{
  Reset();
}

//_______________________
TFndVertex::~TFndVertex()
{  
  Reset();  
}

//_______________________
void TFndVertex::Reset(){
  // reset all data-members
  fPID = 0;
  bzero(fPosition,sizeof(fPosition));
  fDistFromPrimary = -1;
  fZtollerance = -1;
}


ClassImp(TFndTrack)
  
//_______________________
TFndTrack::TFndTrack():
  fVertexID(),
  fCharge(),fChargeAmbig(),fFwd(),
  fStart(),fStop(),
  fTOF(),fEnergy(),
  fNumOfHits(),fPath(),
  fPR_Helix(),fPR_MomVert(),
  fFitErr(),fLength(),fChiSq(),
  fFit_MomVert(),fFit_MomVertErr(),
  fDeDx(),fCorr_DeDx(),
  fExtrapolated(),fBackTrack(),
  fType(),fDistVert(),
  fIsimCos(),fOsimCos(),fLmd1Cos(),fLmd2Cos(),
  fSpecMom()
{
  Reset();
}

//_______________________
TFndTrack::~TFndTrack(){

  Reset();
}


//_______________________
void TFndTrack::Reset(){
  // reset all data-members

  fVertexID = -1;
  fCharge = -2;
  fChargeAmbig = kFALSE;
  fFwd = kFALSE;

  for(Int_t i = (Int_t)E_Trk_X; i < (Int_t)E_Trk_Vect_End; i++ ){
    fStart[i] = 0;
    fStop[i] = 0;
  }
  // ---
  fTOF = 0;
  fEnergy = 0;
  
  fNumOfHits = 0;
  fPath = 0;  
  
  for(Int_t i = (Int_t)E_Hel_Xc; i < (Int_t)E_Hel_Geo_End; i++ ) fPR_Helix[i] = 0;
  for(Int_t i = (Int_t)E_Hel_Mom; i < (Int_t)E_Hel_Mom_End; i++) fPR_MomVert[i] = 0;
  // ---
  
  // by fitting process and extrapolation
  fFitErr = 0;
  fLength = 0;
  
  for(Int_t i = (Int_t)E_Trk_ChiSq_DEV; i < (Int_t)E_Trk_ChiSq_End; i++) fChiSq[i] = 0;
  
  for(Int_t i = (Int_t)E_Hel_Mom; i < (Int_t)E_Hel_Mom_End; i++){
    fFit_MomVert[i] = 0; // fitted momentum
    fFit_MomVertErr[i] = 0; // errors on fitted momentum
  }  
  for(Int_t i=0;i<2;i++) fDeDx[i] = 0;
  for(Int_t i=0;i<4;i++) fCorr_DeDx[i] = 0;

  fExtrapolated = kFALSE;
  for(Int_t i = (Int_t)E_Trk_Bcktrk_NormAng; i < (Int_t)E_Trk_Bcktrk_End; i++ ){
    fBackTrack[i] = 0;
  }

  // --- support for short tracks
  fType = 0;
  fDistVert = 0;
  // 
  fIsimCos = 0;
  fOsimCos = 0;
  fLmd1Cos = 0;
  fLmd2Cos = 0;
  fSpecMom = 0;

}

//_______________________
void TFndTrack::EvalTrack(){
  
#ifndef FIDA_USE_SHORT
  Error("EvalTrack","This method is meaningful is you are not using short tracks!");
  return;
#endif

  fNumOfHits = 0;
  fFwd = kFALSE;
  
  if(fType == 0) return; // no hit: nothing to do...
  
  Int_t isi = (Int_t)(fType%10);
  Int_t osi = (Int_t)(fType%100) - isi;
  Int_t lm1 = (Int_t)(fType%1000) - osi - isi;
  Int_t lm2 = (Int_t)(fType%10000) - lm1 - osi - isi; 
  Int_t stb = fType - lm2 - lm1 - osi - isi;
  
  osi = osi / 10;
  lm1 = lm1 / 100;
  lm2 = lm2 / 1000;
  stb = stb / 10000;

  //   cout << "isi: " << isi << endl;
  //   cout << "osi: " << osi << endl;
  //   cout << "lm1: " << lm1 << endl;
  //   cout << "lm2: " << lm2 << endl;
  //   cout << "stb: " << stb << endl;
  
  fNumOfHits += isi;
  fNumOfHits += osi;
  fNumOfHits += lm1;
  fNumOfHits += lm2;
  fNumOfHits += stb;
  
  // --- fwd evaluation
  if(isi == 0 && fNumOfHits > 1) fFwd = kTRUE;

  //   cout << "fNumOfHits: " << fNumOfHits << endl;
  //   cout << "FWD       : " << fFwd << endl;
  //   cout << "FitVal    : " << fFitErr << endl;
  //   cout << "--- --- ---" << endl;
  
  // --- momentum inside spectrometer
  fSpecMom = fFit_MomVert[TFndTrack::E_Hel_Mom] - 
    fBackTrack[TFndTrack::E_Trk_Bcktrk_dPtgt_spline] - 
    fBackTrack[TFndTrack::E_Trk_Bcktrk_dPtgt_spline_cor];
}

//_______________________
void TFndTrack::SetPath(UInt_t tofi,UInt_t isim,UInt_t osim,UInt_t lmd_inn,UInt_t lmd_out,UInt_t tofo){
  // --- description of "path" [hex code] (zero in case of missing hit):
  //      digit 0: TOFINO slab (1-12) [0x1  - 0xC]
  //      digit 1: ISIM module (1- 8) [0x1  - 0x8]
  //      digit 2: OSIM module (1-10) [0x11 - 0xA]
  //      digit 3: INN LMD dch (1- 8) [0x1  - 0x8]
  //      digit 4: OUT LMD dch (1- 8) [0x1  - 0x8]
  //      digits 5-6: TOFONE slab (1-72) [0x1  - 0x48]
  //      digit 7: free
  
  fPath = 0;
  
  // --- tofino
  UInt_t tmp_v = tofi;
  tmp_v = tmp_v & 0xF;  
  fPath = fPath | tmp_v;
  
  // --- isim
  tmp_v = isim;
  tmp_v = tmp_v & 0xF;  
  fPath = fPath | (tmp_v << 4);
  
  // --- osim
  tmp_v = osim;
  tmp_v = tmp_v & 0xF;  
  fPath = fPath | (tmp_v << 8);
  
  // --- lmd inner
  tmp_v = lmd_inn;
  tmp_v = tmp_v & 0xF;  
  fPath = fPath | (tmp_v << 12);
  
  // --- lmd outer
  tmp_v = lmd_out;
  tmp_v = tmp_v & 0xF;  
  fPath = fPath | (tmp_v << 16);
  
  // --- tofone
  tmp_v = tofo;
  tmp_v = tmp_v & 0xFF;  
  fPath = fPath | (tmp_v << 20);
  
}

//_______________________
UInt_t TFndTrack::GetPath(UInt_t &tofi,UInt_t &isim,UInt_t &osim,UInt_t &lmd_inn,UInt_t &lmd_out,UInt_t &tofo){
  // the encoded path is returned,
  // single detector channels are passed for reference (see arguments)  

  tofi =    GetPath_Tofino();
  isim =    GetPath_Isim();
  osim =    GetPath_Osim();
  lmd_inn = GetPath_Lmd_Inn();
  lmd_out = GetPath_Lmd_Out();
  tofo =    GetPath_Tofone();
  

  return fPath;
}

//_______________________
UInt_t TFndTrack::GetPath_Tofino(){

  UInt_t res =  (fPath & 0xF);
  return res;
}

//_______________________
UInt_t TFndTrack::GetPath_Isim(){
  
  UInt_t res = ( (fPath & 0xF0)     >> 4 );
  return res;
}

//_______________________
UInt_t TFndTrack::GetPath_Osim(){
  
  UInt_t res = ( (fPath & 0xF00)    >> 8 );
  return res;
}

//_______________________
UInt_t TFndTrack::GetPath_Lmd_Inn(){
  
  UInt_t res = ( (fPath & 0xF000)   >> 12 );
  return res;
}

//_______________________
UInt_t TFndTrack::GetPath_Lmd_Out(){
  
  UInt_t res = ( (fPath & 0xF0000)  >> 16 );
  return res;
}

//_______________________
UInt_t TFndTrack::GetPath_Tofone(){
  
  UInt_t res = ( (fPath & 0xFF00000)  >> 20 );
  return res;
}

//_______________________
void TFndTrack::PrintData(Int_t depth){

  if(depth < 1){
    Warning("PrintData","Nothing to print if depth < 1.");
    return;
  }
  
  TString msg = "";
  TString clin = "";

  clin.Form("\n --- --- --- TRACK  data --- --- ---\n"); msg+=clin;
 
  clin.Form("  -> Charge ........: %.0f\n",fCharge); msg+=clin;
  clin.Form("  -> Charge ambig.  : %i\n",(Int_t)(fChargeAmbig)); msg+=clin;
  clin.Form("  -> Time Of Flight : %.2f\n",fTOF); msg+=clin;

  if(fCharge == E_Trk_Neut){
    clin.Form("  -> Evaluated energy: %.2f\n",fEnergy); msg+=clin;
    return;
  }

  clin.Form("  -> Is forward: %i\n",fFwd); msg+=clin;
  clin.Form("  -> Num. of hits: %d\n",fNumOfHits); msg+=clin;
  clin.Form("  -> Path code: 0X%x\n",fPath); msg+=clin;

  if(depth >= 2){
    clin.Form("  --> Start point: (%.3f, %.3f, %.3f); time: %.3f\n",
              fStart[E_Trk_X],
              fStart[E_Trk_Y],
              fStart[E_Trk_Z],
              fStart[E_Trk_T]
              ); 
    msg+=clin;
    clin.Form("  --> Stop point : (%.3f, %.3f, %.3f); time: %.3f\n",
              fStop[E_Trk_X],
              fStop[E_Trk_Y],
              fStop[E_Trk_Z],
              fStop[E_Trk_T]
              );
    msg+=clin;
  }

  if(depth >= 3){
    clin.Form("  ---> Start point dir-cos.: (%.3f, %.3f, %.3f)\n",
              fStart[E_Trk_cosX],
              fStart[E_Trk_cosY],
              fStart[E_Trk_cosZ]
              );
    msg+=clin;
    clin.Form("  ---> Stop point dir-cos. : (%.3f, %.3f, %.3f)\n",
              fStop[E_Trk_cosX],
              fStop[E_Trk_cosY],
              fStop[E_Trk_cosZ]
              );
    msg+=clin;
  }
  // ---
  clin.Form("             --- P.R. ---\n"); msg+=clin;

  if(depth >= 3){
    clin.Form("  ---> P.R. Helix (Xc, Yc, R): %.3f, %.3f, %.3f\n",
              fPR_Helix[E_Hel_Xc],
              fPR_Helix[E_Hel_Yc],
              fPR_Helix[E_Hel_R]
              );
    msg+=clin;
  }
  if(depth >= 2){
    clin.Form("  --> P.R. Mom (mom, lambda, phi): %.3f, %.3f, %.3f\n",
              fPR_MomVert[E_Hel_Mom],
              fPR_MomVert[E_Hel_Lam],
              fPR_MomVert[E_Hel_Phi]
              );
    msg+=clin;
  }

  // ---
  clin.Form("             --- FIT ---\n"); msg+=clin;
  
  clin.Form("  -> Fitting error code: %d\n",fFitErr); msg+=clin;
  
  if(depth >= 2){
    clin.Form("  --> Fitted Length: %.3f\n",fLength); msg+=clin;
    clin.Form("  --> Fit Chi^2 (DEV,RES,LOST,STEREO): %.3f, %.3f, %.3f, %.3f\n",
              fChiSq[E_Trk_ChiSq_DEV],
              fChiSq[E_Trk_ChiSq_RES],
              fChiSq[E_Trk_ChiSq_LOSTstb],
              fChiSq[E_Trk_ChiSq_STEREOstb]
              );
    msg+=clin;
  }

  clin.Form("  -> Fit Mom (mom, lambda, phi): %.3f, %.3f, %.3f\n",
            fFit_MomVert[E_Hel_Mom],
            fFit_MomVert[E_Hel_Lam],
            fFit_MomVert[E_Hel_Phi]
            );
  msg+=clin;
  
  if(depth >= 2){
    clin.Form("  --> Fit Mom Err. (mom, lambda, phi): %.3f, %.3f, %.3f\n",
              fFit_MomVertErr[E_Hel_Mom],
              fFit_MomVertErr[E_Hel_Lam],
              fFit_MomVertErr[E_Hel_Phi]
              );    
    msg+=clin;
  }
  
  clin.Form("  -> ISIM dE/dx : %.3f\n", fDeDx[0]); msg+=clin;
  clin.Form("  -> OSIM dE/dx : %.3f\n", fDeDx[1]); msg+=clin;
  //
  clin.Form("  -> ISIM corr. dE/dx : %.3f\n", fCorr_DeDx[0]); msg+=clin;
  clin.Form("  -> OSIM corr. dE/dx : %.3f\n", fCorr_DeDx[1]); msg+=clin;
  clin.Form("  -> LMD1 corr. dE/dx : %.3f\n", fCorr_DeDx[2]); msg+=clin;
  clin.Form("  -> LMD2 corr. dE/dx : %.3f\n", fCorr_DeDx[3]); msg+=clin;

  
  clin.Form("         --- BACK-TRACKING ---\n"); //fExtrapolated
  clin.Form("  -> Extrapolation performed        : %i\n",  (Int_t) (fExtrapolated) ); msg+=clin;
  if(fExtrapolated){
    clin.Form("  -> BackTracking (Norm-Angle)      : %.3f\n", fBackTrack[E_Trk_Bcktrk_NormAng]); msg+=clin;
    clin.Form("  -> BackTracking (Surf-Approach)   : %.3f\n", fBackTrack[E_Trk_Bcktrk_SurfApproach]); msg+=clin;
    clin.Form("  -> BackTracking (Max-Approach)    : %.3f\n", fBackTrack[E_Trk_Bcktrk_MaxApproach]); msg+=clin;
    clin.Form("  -> BackTracking (Surf-Plane-path) : %.3f\n", fBackTrack[E_Trk_Bcktrk_SurfPlanePath]); msg+=clin;
    clin.Form("  -> BackTracking (Extrap-distance) : %.3f\n", fBackTrack[E_Trk_Bcktrk_ExtrDist]); msg+=clin;
    if(depth >= 2){
      clin.Form("  --> BackTracking (Delta P)         : %.3f\n", fBackTrack[E_Trk_Bcktrk_dPtgt_spline]); msg+=clin;
      clin.Form("  --> BackTracking (Delta P - cor.)  : %.3f\n", fBackTrack[E_Trk_Bcktrk_dPtgt_spline_cor]); msg+=clin;
      clin.Form("  --> BackTracking (geant PID code)  : %.0f\n", fBackTrack[E_Trk_Bcktrk_pid]); msg+=clin;
    }
  }
  clin.Form("  -> Track TYPE : %.d\n", fType); msg+=clin;
  clin.Form("  -> Dist_vert  : %.3f\n", fDistVert); msg+=clin;
  clin.Form("  -> Dir-cos-ISIM : %.3f\n", fIsimCos); msg+=clin;
  clin.Form("  -> Dir-cos-OSIM : %.3f\n", fOsimCos); msg+=clin;
  clin.Form("  -> Dir-cos-LMD1 : %.3f\n", fLmd1Cos); msg+=clin;
  clin.Form("  -> Dir-cos-LMD1 : %.3f\n", fLmd2Cos); msg+=clin;
  clin.Form("  -> Spec.Mom.    : %.3f\n", fSpecMom); msg+=clin;
  clin.Form(" --- --- --- --- --- --- --- --- ---\n"); msg+=clin;
  
  Printf(msg.Data());
}

---