GUI/TFndEvdTrack.cxx

// @(#)fROOT/GUI:$Name:  $:$Id: TFndEvdTrack.cxx,v 1.10 2007/09/24 07:32:41 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2007/04/04

//                                                       //
// This class has been developed in order to provide a   //
//    simple interface from the FINDA standard track     //
//    description to the ROOT one. In principle tracks   //
//    are helyces, but they can be simple lines (if B=0) //
//                                                       //


#include "TFndEvdTrack.h"
#include <Riostream.h>

ClassImp(TFndEvdTrack)

//___________________________
TFndEvdTrack::TFndEvdTrack():
  fLine(),fHelix(),fHelixPoints(),
  fB(),fPID(),fMode((Int_t)E_FndTrack_None)
{
  
  Info("TFndEvdTrack","creating new dummy evd-track: nothing will happen...");
}

//___________________________
TFndEvdTrack::TFndEvdTrack(Double_t Bx,Double_t By,Double_t Bz):
  fLine(),fHelix(),fHelixPoints(),
  fB(),fPID(),fMode((Int_t)E_FndTrack_None)
{

  fB[0] = Bx;
  fB[1] = By;
  fB[2] = Bz;

}

//___________________________
TFndEvdTrack::~TFndEvdTrack(){
  
  //Info("~TFndEvdTrack","destroying evd-track");

  delete fLine;
  delete fHelix;
  delete fHelixPoints;
}

//___________________________
void TFndEvdTrack::BuildLine(const Double_t &x,const Double_t &y,const Double_t &z,const Double_t &phi_d, const Double_t &lam_d,const Double_t &length){
  // note:
  //
  // both phi_d and lam_d : degrees
  //
  //        lambda = 90 - theta (theta >= 0)
  //        lambda = - 90 + theta (theta < 0)
  
  if(fMode == (Int_t)E_FndTrack_Helix){
    Warning("InitLine","Can not build line: helix already defined");
    return;
  }
  
  if(fLine) delete fLine;
  fLine = new TPolyLine3D(2);
  
  Double_t theta_rad = TMath::DegToRad() * ( (Double_t)(90 -lam_d) );

  fLine->SetNextPoint(x,y,z);
  Double_t xl = x + length * TMath::Sin(theta_rad) * TMath::Cos(TMath::DegToRad() * phi_d);
  Double_t yl = y + length * TMath::Sin(theta_rad) * TMath::Sin(TMath::DegToRad() * phi_d);
  Double_t zl = z + length * TMath::Cos(theta_rad);
  
  fLine->SetNextPoint(xl,yl,zl);
  fMode = (Int_t)E_FndTrack_Line;

  SetWidth(3);
}

//___________________________
void TFndEvdTrack::BuildLine(const Double_t &x,const Double_t &y,const Double_t &z,const Double_t &cx,const Double_t &cy,const Double_t &cz,const Double_t &length){
  // this method uses director-cosines
  
  Double_t theta_r = 0;
  Double_t phi_r = 0;
  RefSys_CosDir_To_Spheric(cx,cy,cz,theta_r,phi_r);

  Double_t phi_d = (Double_t) (TMath::RadToDeg() * phi_r);
  Double_t lam_d = (Double_t) ( 90 - (TMath::RadToDeg() * theta_r) );

  BuildLine(x,y,z,phi_d, lam_d,length);

}

//___________________________
void TFndEvdTrack::BuildHelix(const Double_t &x,const Double_t &y,const Double_t &z,const Int_t &charge,const Double_t &rad, const Double_t &phi_d, const Double_t &lam_d, const Double_t &Length){
  // note:
  //
  // both phi_d and lam_d : degrees
  //
  //        lambda = 90 - theta (theta >= 0)
  //        lambda = - 90 + theta (theta < 0)  
  
  Double_t Bmod_sq = 0;
  for(Int_t i=0;i<3;i++) Bmod_sq += fB[i] * fB[i] ;
  if(Bmod_sq==0){
    Warning("BuildHelix","Null magnetic field: Must use a line instead of a helix");
    return;  
  }
  
  if(fMode == (Int_t)E_FndTrack_Line){
    Warning("InitHelix","Can not build helix: straight track already defined");
    return;
  }
  
  InitHelix(charge,rad, lam_d); 
  Double_t z_sig = (lam_d >=0 ) ? 1 : -1;
  
  SetHelix(x,y,z,phi_d,z_sig);
  LoadHelixPoints(Length);

  SetWidth(3);
}

//___________________________
void TFndEvdTrack::BuildHelix(const Double_t &x,const Double_t &y,const Double_t &z,const Int_t &charge,const Double_t &rad, const Double_t &cx,const Double_t &cy,const Double_t &cz, const Double_t &Length){
  // note:
  //        lambda = 90 - theta (theta >= 0)
  //        lambda = - (90 + theta) (theta < 0)

  Double_t theta_r = 0;
  Double_t phi_r = 0;
  RefSys_CosDir_To_Spheric(cx,cy,cz,theta_r,phi_r);
  
  Double_t phi_d = (Double_t) (TMath::RadToDeg() * phi_r);
  //   Double_t lam_d = (theta_r >=0) ? 
  //     (Double_t) ( 90 - (TMath::RadToDeg() * theta_r) ):
  //     (Double_t) ( 90 + (TMath::RadToDeg() * theta_r) );
  Double_t lam_d = (Double_t) ( 90 - (TMath::RadToDeg() * theta_r) );
  
  BuildHelix(x,y,z,charge,rad, phi_d, lam_d, Length);
}

//___________________________
void TFndEvdTrack::InitHelix(const Int_t &charge,const Double_t &rad, const Double_t &lam_d){
  
  
  if(fHelix) delete fHelix;
  Double_t curv  =  1/rad;
  Double_t lambda = TMath::DegToRad() * lam_d;
  Double_t zstep= TMath::Abs( TMath::TwoPi() * rad * TMath::Tan(lambda) );  
  //
  fHelix = new TGeoHelix(curv, zstep, charge);
  fHelix->SetField(fB[0], fB[1], fB[2]);
  //
  fMode = (Int_t)E_FndTrack_Helix;
}
//___________________________
void TFndEvdTrack::SetHelix(const Double_t &x,const Double_t &y,const Double_t &z, const Double_t &phi_d,const Double_t &z_sig){

  if(!fHelix){
    Warning("SetHelix","Could not set helix parameters: helix not available");
    return;
  }
  Double_t phi   = TMath::DegToRad() * phi_d; // phi initial angle
  fHelix->InitPoint(x,y,z);
  fHelix->InitDirection(TMath::Cos(phi), TMath::Sin(phi), z_sig, kFALSE);
}

//___________________________
void TFndEvdTrack::LoadHelixPoints(const Double_t &MaxLength,const Double_t step,const Int_t N_max_points){
  
  if(!fHelix){
    Warning("LoadHelixPoints","Could not load helix points: helix not available");
    return;
  }
  
  delete fHelixPoints;
  fHelixPoints = new TPointSet3D(2000);
  
  const Double_t* p = fHelix->GetCurrentPoint();
  Int_t N_all = 0;  
  for(N_all=0; N_all<=N_max_points; N_all++) {
    fHelixPoints->SetNextPoint( p[0], p[1], p[2] );    
    fHelix->Step(step);
    if(fHelix->GetStep() > MaxLength) break;
  }
  
  fHelixPoints->SetMarkerColor(E_FndTrCol_Default);
  //  Printf("Helix points ready , number of points %d.\n", N_all);
  
}

//___________________________
void TFndEvdTrack::SetPID(const Int_t &pid){

  fPID = pid;

  //  cout << "Setting PID: " << fPID << endl;

  //  UInt_t mod_pid = TMath::Abs(fPID);
  Int_t col;
  switch(fPID){
  case (Int_t)(FPh_PID_Electron) : col = E_FndTrCol_Elec;    break;
  case (Int_t)(FPh_PID_Positron) : col = E_FndTrCol_Posit;   break;
  case (Int_t)(FPh_PID_Kaon_min) : col = E_FndTrCol_KaonMin; break;
  case (Int_t)(FPh_PID_Kaon_plu) : col = E_FndTrCol_KaonPlu; break;
  case (Int_t)(FPh_PID_Muon_min) : col = E_FndTrCol_MuonMin; break;
  case (Int_t)(FPh_PID_Muon_plu) : col = E_FndTrCol_MuonPlu; break;
  case (Int_t)(FPh_PID_Pi_min)   : col = E_FndTrCol_PiMin;   break;
  case (Int_t)(FPh_PID_Pi_plu)   : col = E_FndTrCol_PiPlu;   break;
  case (Int_t)(FPh_PID_Proton)   : col = E_FndTrCol_Prot;    break;
  case (Int_t)(FPh_PID_Neutron)  : col = E_FndTrCol_Neut;    break;
  case (Int_t)(FPh_PID_Gamma)    : col = E_FndTrCol_Phot;    break;
  default: col = (Int_t)E_FndTrCol_Default; break;
    
  }
  SetColor(col);

}

//___________________________
void TFndEvdTrack::SetColor(const Int_t &col){
  // will update current drawable object
  
  if(fHelixPoints) fHelixPoints->SetMarkerColor(col);
  if(fLine) fLine->SetLineColor(col);
  
}
//___________________________
void TFndEvdTrack::SetWidth(const Double_t &w){

  if(fHelixPoints){
    fHelixPoints->SetMarkerStyle(4);
    fHelixPoints->SetMarkerSize(w/8);
  }
  if(fLine) fLine->SetLineWidth((Width_t)w);
}

//___________________________
TObject *TFndEvdTrack::GetDrawable(){
  // can be used for irect drawing
  //  mytrack->GetDrawableTrack()->Draw();

  switch(fMode){
  case (Int_t)E_FndTrack_Line : return fLine;
  case (Int_t)E_FndTrack_Helix: return fHelixPoints;
  default: return 0;
  }

}

//___________________________
void TFndEvdTrack::DrawTrack(Option_t *option){
  
  if(GetDrawable()) GetDrawable()->Draw(option); 
}

---