---

GflashTrajectory.cc

Go to the documentation of this file.

// Most methods of this class are excerpted from CDF Helix and Trajectory class

#include "SimG4Core/GFlash/interface/GflashTrajectory.h"
#include "SimG4Core/GFlash/interface/GflashTrajectoryPoint.h"

#include "CLHEP/Geometry/Point3D.h"
#include "CLHEP/Geometry/Vector3D.h"

GflashTrajectory::GflashTrajectory()
  :
   _cotTheta(0.0),_curvature(0.0),_z0(0.0),_d0(0.0),_phi0(0.0),
   _isStale(1),
   _sinPhi0(2),_cosPhi0(2),_sinTheta(2),_cosTheta(2),
   _s(-999.999),
   _aa(2),_ss(2),_cc(2)
{
  //detault constructor
}

//GflashTrajectory::GflashTrajectory(const HepVector3D & MomentumGev, const HepPoint3D  & PositionCm,
//           double q, double BFieldTesla) 
void GflashTrajectory::initializeTrajectory(const HepVector3D & MomentumGev, const HepPoint3D  & PositionCm,
             double q, double BFieldTesla) 
 {
  double CotTheta = 0.0 ;
  double W = 0;
  double Z0 = 0;
  double D0 = 0;
  double Phi0 =0;

  if (BFieldTesla != 0.0 && q != 0.0) {
    double CurvatureConstant=0.0029979;
    double Helicity       = -1.0 * fabs(BFieldTesla) * fabs(q) / (BFieldTesla*q);
    double Radius         = fabs(MomentumGev.perp()/(CurvatureConstant*BFieldTesla*q));
    
    if(Radius==0.0) W = HUGE_VAL;   else     W        = Helicity/Radius;
    double phi1     = MomentumGev.phi();
    double x        = PositionCm.x(),        y        = PositionCm.y(),    z = PositionCm.z(); 
    double sinPhi1  = sin(phi1),             cosPhi1  = cos(phi1);
    double gamma    = atan((x*cosPhi1 + y*sinPhi1)/(x*sinPhi1-y*cosPhi1 -1/W));
    Phi0            = phi1+gamma;
    if(Phi0 >  M_PI) Phi0 = Phi0 - 2.0*M_PI; 
    if(Phi0 < -M_PI) Phi0 = Phi0 + 2.0*M_PI; 
    D0              = ((1/W + y*cosPhi1 - x*sinPhi1) /cos(gamma) - 1/W);
    CotTheta        = MomentumGev.z()/MomentumGev.perp();
    Z0              = z + gamma*CotTheta/W;
  }
  else {
    Hep3Vector direction          = MomentumGev.unit(); 
    Hep3Vector projectedDirection = Hep3Vector(direction.x(),direction.y(),0.0).unit();
    double s                      = projectedDirection.dot(PositionCm);
    double sprime                 = s/sin(direction.theta());
    Z0                            = (PositionCm - sprime*direction).z();
    Phi0                          = MomentumGev.phi();
    CotTheta                      = MomentumGev.z()/MomentumGev.perp();
    W                             = 0.0;
    D0                           = (PositionCm.y()*cos(Phi0) - PositionCm.x()*sin(Phi0));
  } 
  
   _cotTheta=CotTheta;
   _curvature=W/2;
   _z0=Z0;
   _d0=D0;
   _phi0=Phi0;

   _isStale=1;
   _s=-999.999;
   _aa =-999.999; 
   _ss =-999.999; 
   _cc =-999.999; 
   _sinPhi0 = 1.0;
   _cosPhi0 = 1.0;
   _sinTheta = 1.0;
   _cosTheta = 1.0;
}

GflashTrajectory::~GflashTrajectory()
{
}

void GflashTrajectory::setCotTheta(double cotTheta) {
  _cotTheta=cotTheta;
  _isStale=true;
}

void GflashTrajectory::setCurvature(double curvature){
  _curvature=curvature;
  _isStale=true;
}

void GflashTrajectory::setZ0(double z0) {
  _z0 = z0;
  _isStale=true;
}

void GflashTrajectory::setD0(double d0){
  _d0=d0;
  _isStale=true;
}

void GflashTrajectory::setPhi0(double phi0){
  _phi0=phi0;
  _isStale=true;
}

double GflashTrajectory::getSinPhi0() const{
  _refreshCache();
  return _sinPhi0;
}
double GflashTrajectory::getCosPhi0() const{
  _refreshCache();
  return _cosPhi0;
}
double GflashTrajectory::getSinTheta() const{
  _refreshCache();
  return _sinTheta;
}
double GflashTrajectory::getCosTheta() const{
  _refreshCache();
  return _cosTheta;
}

HepPoint3D GflashTrajectory::getPosition(double s) const
{
  _cacheSinesAndCosines(s);
  if (s==0.0 || _curvature==0.0) {
      return HepPoint3D(-_d0*_sinPhi0+s*_cosPhi0*_sinTheta,
                        _d0*_cosPhi0+s*_sinPhi0*_sinTheta,
                        _z0+s*_cosTheta);
  } else {
      return HepPoint3D((_cosPhi0*_ss-_sinPhi0*(2.0*_curvature*_d0+1.0-_cc))
                        /(2.0*_curvature),
                        (_sinPhi0*_ss+_cosPhi0*(2.0*_curvature*_d0+1.0-_cc))
                        /(2.0*_curvature),   
                        _s*_cosTheta + _z0);
  }
}

HepVector3D GflashTrajectory::getDirection(double s) const
{
  _cacheSinesAndCosines(s);
  if (s==0.0) {
      return HepVector3D(_cosPhi0*_sinTheta,_sinPhi0*_sinTheta,_cosTheta);
  }
  double   xtan     = _sinTheta*(_cosPhi0*_cc -_sinPhi0*_ss); 
  double   ytan     = _sinTheta*(_cosPhi0*_ss +_sinPhi0*_cc); 
  double ztan       = _cosTheta;
  return HepVector3D(xtan,ytan,ztan);
}


void GflashTrajectory::getGflashTrajectoryPoint(GflashTrajectoryPoint& point, double s) const {
  
  _cacheSinesAndCosines(s);

  double cP0sT = _cosPhi0*_sinTheta, sP0sT = _sinPhi0*_sinTheta;
  if ( s && _curvature) {
    point.getPosition().set((_cosPhi0*_ss-
                             _sinPhi0*(2.0*_curvature*_d0+1.0-_cc))
                            /(2.0*_curvature),
                            (_sinPhi0*_ss+
                             _cosPhi0*(2.0*_curvature*_d0+1.0-_cc))
                            /(2.0*_curvature),
                            s*_cosTheta + _z0);
    
    point.getMomentum().set(cP0sT*_cc-sP0sT*_ss,
                            cP0sT*_ss+sP0sT*_cc,
                            _cosTheta);
    point.setPathLength(s);
  }
  else {
    point.getPosition().set(-_d0*_sinPhi0+s*cP0sT,
                            _d0*_cosPhi0+s*sP0sT,
                            _z0+s*_cosTheta);
    
    point.getMomentum().set(cP0sT,sP0sT,_cosTheta);
    
    point.setPathLength(s);
  }
  
}

double GflashTrajectory::getPathLengthAtRhoEquals(double rho) const
{
  return (getSinTheta()?(getL2DAtR(rho)/getSinTheta()):0.0);
}

double GflashTrajectory::getPathLengthAtZ(double z) const {
  return (getCosTheta()?(z-getZ0())/getCosTheta():0.0);
}

double GflashTrajectory::getZAtR(double rho) const {
  return _z0 + getCotTheta()*getL2DAtR(rho);
}

double GflashTrajectory::getL2DAtR(double rho) const {

  double L2D;

  double c = getCurvature();
  double d = getD0();

  if (c!=0.0) {
    double rad = (rho*rho-d*d)/(1.0+2.0*c*d);
    double rprime;
    if (rad<0.0) {
      rprime = 0.0;
    }
    else {
      rprime = sqrt( rad );
    }
    if (c*rprime > 1.0 || c*rprime < -1.0) {
      L2D = c*rprime > 0. ? M_PI/c : -M_PI/c;
    }
    else
      L2D = asin(c*rprime)/c;
  } else {
    double rad = rho*rho-d*d;
    double rprime;
    if (rad<0.0) rprime = 0.0;
    else rprime = sqrt( rad );
    
    L2D = rprime;
  }
  return L2D;
}

// Update _sinTheta,_cosTheta,_sinPhi0, and _cosPhi0
void GflashTrajectory::_refreshCache() const {
  if (_isStale) {
    _isStale=false;
    double theta;
    if ( _cotTheta==0.0 ) {
       theta = M_PI/2.0;
    }
    else {
       theta=atan(1.0/_cotTheta);
       if (theta<0.0) theta+=M_PI;
    }
    if (theta==0.0) {
      _sinTheta=0.0;
      _cosTheta=1.0;
    }
    else {
      _cosTheta=cos(theta);
      _sinTheta=sqrt(1-_cosTheta*_cosTheta);
    }
    if (_phi0==0.0) {
      _sinPhi0=0.0;
      _cosPhi0=1.0;
    }
    else {
      _cosPhi0 = cos(_phi0);
      _sinPhi0 = sin(_phi0);
      //      _sinPhi0 = sqrt(1.0-_cosPhi0*_cosPhi0);
      //      if (_phi0>M_PI) _sinPhi0 = -_sinPhi0;
    }
  }
}
// Update _s, _aa, _ss, and _cc if the arclength has changed.
void GflashTrajectory::_cacheSinesAndCosines(double s) const {
  _refreshCache();
  if (_s!=s){
    _s=s;
    _aa=2.0*_s*_curvature*_sinTheta;
    if (_aa==0.0) {
      _ss=0.0;
      _cc=1.0;
    }
    else {
      _ss=sin(_aa);
      _cc=cos(_aa);
    }
  }
}

---