TrTrack.cpp Source File

00001 // $Id: $ // Include files
00002 
00003 // local
00004 #include "Event/TrTrack.h"
00005 
00006 //-----------------------------------------------------------------------------
00007 // Implementation file for class : TrTrack
00008 //
00009 // 2004-10-07 : Eduardo Rodrigues
00010 //-----------------------------------------------------------------------------
00011 
00012 
00013 //=============================================================================
00014 // Retrieve the position and momentum vectors and the corresponding
00015 // 6D covariance matrix (pos:1->3,mom:4-6) of a track closest to the beam-line
00016 //=============================================================================
00017 StatusCode TrTrack::positionAndMomentum( HepPoint3D &pos,
00018                                          HepVector3D &mom,
00019                                          HepSymMatrix &cov6D )
00020 {
00021   m_closestState -> positionAndMomentum( pos, mom, cov6D );
00022 
00023   return StatusCode::SUCCESS;
00024 }
00025 
00026 //=============================================================================
00027 // Retrieve the position and momentum vectors and the corresponding
00028 // 6D covariance matrix (pos:1->3,mom:4-6) of a track at a given z-position
00029 //=============================================================================
00030 StatusCode TrTrack::positionAndMomentum( double z,
00031                                          ITrExtrapolator* extrapolator,
00032                                          ParticleID &pid,
00033                                          HepPoint3D &pos,
00034                                          HepVector3D &mom,
00035                                          HepSymMatrix &cov6D )
00036 {
00037   TrState* closeState = closestState( z );
00038 
00039   StatusCode sc = extrapolator -> propagate( closeState, z, pid );
00040 
00041   if ( sc.isSuccess() ) {
00042     pos   = closeState -> position();
00043     mom   = closeState -> momentum();
00044     cov6D = closeState -> posMomCovariance();
00045   }
00046   return sc;
00047 }
00048 
00049 //=============================================================================
00050 // Retrieve the position and momentum vectors and the corresponding
00051 // 6D covariance matrix (pos:1->3,mom:4-6) at the intersection
00052 // of a track at a given plane
00053 //=============================================================================
00054 StatusCode TrTrack::positionAndMomentum( HepPlane3D &plane,
00055                                          ITrExtrapolator* extrapolator,
00056                                          ParticleID &pid,
00057                                          HepPoint3D &pos,
00058                                          HepVector3D &mom,
00059                                          HepSymMatrix &cov6D )
00060 {
00061   TrState* closeState = closestState( plane );
00062 
00063   StatusCode sc = extrapolator -> propagate( closeState, plane, pid );
00064 
00065   if ( sc.isSuccess() ) {
00066     pos   = closeState -> position();
00067     mom   = closeState -> momentum();
00068     cov6D = closeState -> posMomCovariance();
00069   }
00070   return sc;
00071 }
00072 
00073 //=============================================================================
00074 // Retrieve the 3D-position (+ errors) of a track closest to the beam-line
00075 //=============================================================================
00076 StatusCode TrTrack::position( HepPoint3D &pos,
00077                               HepSymMatrix &errPos )
00078 {
00079   pos    = m_closestState -> position();
00080   errPos = m_closestState -> errPosition();
00081 
00082   return StatusCode::SUCCESS;
00083 };
00084 
00085 //=============================================================================
00086 // Retrieve the 3D-position vector (+ errors) of a track at a given z-position
00087 //=============================================================================
00088 StatusCode TrTrack::position( double z,
00089                               ITrExtrapolator* extrapolator,
00090                               ParticleID &pid,
00091                               HepPoint3D &pos,
00092                               HepSymMatrix &errPos )
00093 {
00094   TrState* closeState = closestState( z );
00095 
00096   StatusCode sc = extrapolator -> propagate( closeState, z, pid );
00097 
00098   if ( sc.isSuccess() ) {
00099     pos    = closeState -> position();
00100     errPos = closeState -> errPosition();
00101 }
00102 
00103   return sc;
00104 };
00105 
00106 //=============================================================================
00107 // Retrieve the 3D-position vector (+ errors) of a track
00108 // at the intersection of a track with a given plane
00109 //=============================================================================
00110 StatusCode TrTrack::position( HepPlane3D &plane,
00111                               ITrExtrapolator* extrapolator,
00112                               ParticleID &pid,
00113                               HepPoint3D &pos,
00114                               HepSymMatrix &errPos )
00115 {
00116   TrState* closeState = closestState( plane );
00117 
00118   StatusCode sc = extrapolator -> propagate( closeState, plane, pid );
00119 
00120   if ( sc.isSuccess() ) {
00121     pos    = closeState -> position();
00122     errPos = closeState -> errPosition();
00123   }
00124   return sc;
00125 };
00126 
00127 //=============================================================================
00128 // Retrieve the slopes (dx/dz,dy/dz,1) of a track closest to the beam-line
00129 //=============================================================================
00130 StatusCode TrTrack::slopes( HepVector3D &slopes,
00131                             HepSymMatrix &errSlopes )
00132 {
00133   slopes    = m_closestState -> slopes();
00134   errSlopes = m_closestState -> errSlopes();
00135 
00136   return StatusCode::SUCCESS;
00137 };
00138 
00139 //=============================================================================
00140 // Retrieve the slopes (dx/dz,dy/dz,1) of a track at a given z-position
00141 //=============================================================================
00142 StatusCode TrTrack::slopes( double z,
00143                             ITrExtrapolator* extrapolator,
00144                             ParticleID &pid,
00145                             HepVector3D &slopes,
00146                             HepSymMatrix &errSlopes )
00147 {
00148   TrState* closeState = closestState( z );
00149 
00150   StatusCode sc = extrapolator -> propagate( closeState, z, pid );
00151 
00152   if ( sc.isSuccess() ) {
00153     slopes    = closeState -> slopes();
00154     errSlopes = closeState -> errSlopes();
00155 }
00156 
00157   return sc;
00158 };
00159 
00160 //=============================================================================
00161 // Retrieve the slopes (dx/dz,dy/dz,1) at the intersection
00162 // of a track with a given plane
00163 //=============================================================================
00164 StatusCode TrTrack::slopes( HepPlane3D &plane,
00165                             ITrExtrapolator* extrapolator,
00166                             ParticleID &pid,
00167                             HepVector3D &slopes,
00168                             HepSymMatrix &errSlopes )
00169 {
00170   TrState* closeState = closestState( plane );
00171 
00172   StatusCode sc = extrapolator -> propagate( closeState, plane, pid );
00173 
00174   if ( sc.isSuccess() ) {
00175     slopes    = closeState -> slopes();
00176     errSlopes = closeState -> errSlopes();
00177   }
00178   return sc;
00179 };
00180 
00181 //=============================================================================
00182 // Retrieve the momentum of a track closest to the beam-line
00183 //=============================================================================
00184 double TrTrack::p()
00185 {
00186   return m_closestState -> p();
00187 };
00188 
00189 //=============================================================================
00190 // Retrieve the momentum of a track at a given z-position
00191 //=============================================================================
00192 StatusCode TrTrack::p( double z,
00193                        ITrExtrapolator* extrapolator,
00194                        ParticleID &pid,
00195                        double p )
00196 {
00197   TrState* closeState = closestState( z );
00198 
00199   StatusCode sc = extrapolator -> propagate( closeState, z, pid );
00200 
00201   if ( sc.isSuccess() ) p = closeState -> p();
00202 
00203   return sc;
00204 };
00205 
00206 //=============================================================================
00207 // Retrieve the momentum at the intersection of a track with a given plane
00208 //=============================================================================
00209 StatusCode TrTrack::p( HepPlane3D &plane,
00210                        ITrExtrapolator* extrapolator,
00211                        ParticleID &pid,
00212                        double p )
00213 {
00214   TrState* closeState = closestState( plane );
00215 
00216   StatusCode sc = extrapolator -> propagate( closeState, plane, pid );
00217 
00218   if ( sc.isSuccess() ) p = closeState -> p();
00219 
00220   return sc;
00221 };
00222 
00223 //=============================================================================
00224 // Retrieve the transverse momentum of a track closest to the beam-line
00225 //=============================================================================
00226 double TrTrack::pt()
00227 {
00228   return m_closestState -> pt();
00229 };
00230 
00231 //=============================================================================
00232 // Retrieve the transvese momentum of a track at a given z-position
00233 //=============================================================================
00234 StatusCode TrTrack::pt( double z,
00235                         ITrExtrapolator* extrapolator,
00236                         ParticleID &pid,
00237                         double pt )
00238 {
00239   TrState* closeState = closestState( z );
00240 
00241   StatusCode sc = extrapolator -> propagate( closeState, z, pid );
00242 
00243   if ( sc.isSuccess() ) pt = closeState -> pt();
00244 
00245   return sc;
00246 };
00247 
00248 //=============================================================================
00249 // Retrieve the tranverse momentum at the intersection
00250 // of a track with a given plane
00251 //=============================================================================
00252 StatusCode TrTrack::pt( HepPlane3D &plane,
00253                         ITrExtrapolator* extrapolator,
00254                         ParticleID &pid,
00255                         double pt )
00256 {
00257   TrState* closeState = closestState( plane );
00258 
00259   StatusCode sc = extrapolator -> propagate( closeState, plane, pid );
00260 
00261   if ( sc.isSuccess() ) pt = closeState -> pt();
00262 
00263   return sc;
00264 };
00265 
00266 //=============================================================================
00267 // Retrieve the momentum vector (+ errors) of a track closest to the beam-line
00268 //=============================================================================
00269 StatusCode TrTrack::momentum( HepVector3D &mom,
00270                               HepSymMatrix &errMom )
00271 {
00272   mom    = m_closestState -> momentum();
00273   errMom = m_closestState -> errMomentum();
00274 
00275   return StatusCode::SUCCESS;
00276 };
00277 
00278 //=============================================================================
00279 // Retrieve the momentum vector (+ errors) of a track at a given z-position
00280 //=============================================================================
00281 StatusCode TrTrack::momentum( double z,
00282                               ITrExtrapolator* extrapolator,
00283                               ParticleID &pid,
00284                               HepVector3D &mom,
00285                               HepSymMatrix &errMom )
00286 {
00287   TrState* closeState = closestState( z );
00288 
00289   StatusCode sc = extrapolator -> propagate( closeState, z, pid );
00290 
00291   if ( sc.isSuccess() ) {
00292     mom    = closeState -> momentum();
00293     errMom = closeState -> errMomentum();
00294 }
00295 
00296   return sc;
00297 };
00298 
00299 //=============================================================================
00300 // Retrieve the momentum vector (+ errors) of a track
00301 // at the intersection of a track with a given plane
00302 //=============================================================================
00303 StatusCode TrTrack::momentum( HepPlane3D &plane,
00304                               ITrExtrapolator* extrapolator,
00305                               ParticleID &pid,
00306                               HepVector3D &mom,
00307                               HepSymMatrix &errMom )
00308 {
00309   TrState* closeState = closestState( plane );
00310 
00311   StatusCode sc = extrapolator -> propagate( closeState, plane, pid );
00312 
00313   if ( sc.isSuccess() ) {
00314     mom    = closeState -> momentum();
00315     errMom = closeState -> errMomentum();
00316   }
00317   return sc;
00318 };
00319 
00320 //=============================================================================
00321 // Retrieve the 6D covariance matrix (x,y,z,px,py,pz)
00322 // of a track closest to the beam-line
00323 //=============================================================================
00324 StatusCode TrTrack::posMomCovariance( HepSymMatrix &cov6D )
00325 {
00326   cov6D = m_closestState -> posMomCovariance();
00327 
00328   return StatusCode::SUCCESS;
00329 };
00330 
00331 //=============================================================================
00332 // Retrieve the 6D covariance matrix (x,y,z,px,py,pz)
00333 // of a track at a given z-position
00334 //=============================================================================
00335 StatusCode TrTrack::posMomCovariance( double z,
00336                                       ITrExtrapolator* extrapolator,
00337                                       ParticleID &pid,
00338                                       HepSymMatrix &cov6D )
00339 {
00340   TrState* closeState = closestState( z );
00341 
00342   StatusCode sc = extrapolator -> propagate( closeState, z, pid );
00343 
00344   if ( sc.isSuccess() ) cov6D = closeState -> posMomCovariance();
00345 
00346   return sc;
00347 };
00348 
00349 //=============================================================================
00350 // Retrieve the 6D covariance matrix (x,y,z,px,py,pz)
00351 // at the intersection of a track with a given plane
00352 //=============================================================================
00353 StatusCode TrTrack::posMomCovariance( HepPlane3D &plane,
00354                                       ITrExtrapolator* extrapolator,
00355                                       ParticleID &pid,
00356                                       HepSymMatrix &cov6D )
00357 {
00358   TrState* closeState = closestState( plane );
00359 
00360   StatusCode sc = extrapolator -> propagate( closeState, plane, pid );
00361 
00362   if ( sc.isSuccess() ) cov6D = closeState -> posMomCovariance();
00363 
00364   return sc;
00365 };
00366 
00367 //=============================================================================
00368 // Retrieve the pointer to the state closest to the given z-position
00369 //=============================================================================
00370 TrState* TrTrack::closestState( double z ) {
00371   double minDist = 999999999.;
00372   TrState* best = 0;
00373   for ( SmartRefVector<TrState>::iterator it = m_states.begin() ;
00374         m_states.end() != it; it++ ) {
00375     if ( minDist > fabs( z - (*it)->z() ) ) {
00376       minDist = fabs( z-(*it)->z() );
00377       best    = *it;
00378     }
00379   }
00380   return best;
00381 }
00382 
00383 //=============================================================================
00384 // Retrieve the pointer to the state closest to the given plane
00385 //=============================================================================
00386 TrState* TrTrack::closestState( HepPlane3D &plane ) {
00387   double minDist = 999999999.;
00388   double dist;
00389   TrState* best = 0;
00390   for ( SmartRefVector<TrState>::iterator it = m_states.begin() ;
00391         m_states.end() != it; it++ ) {
00392     dist = plane.distance( ((*it) -> position()) );
00393     if ( minDist > dist ) {
00394       minDist = dist;
00395       best    = *it;
00396     }
00397   }
00398   return best;
00399 }
00400 
00401 //=============================================================================
00402 // Clone the track
00403 //=============================================================================
00404 TrTrack* TrTrack::clone()
00405 {
00406   return new TrTrack(*this);
00407 };
00408 
00409 //=============================================================================