ITrExtrapolator.h Source File

00001 // $Id: $
00002 #ifndef TRKERNEL_ITREXTRAPOLATOR_H
00003 #define TRKERNEL_ITREXTRAPOLATOR_H 1
00004 
00005 // from Gaudi
00006 #include "GaudiKernel/IAlgTool.h"
00007 // from LHCB
00008 #include "Kernel/ParticleID.h"
00009 // from CLHEP
00010 #include "CLHEP/Matrix/Matrix.h"
00011 #include "CLHEP/Geometry/Point3D.h"
00012 #include "CLHEP/Geometry/Vector3D.h"
00013 #include "CLHEP/Geometry/Plane3D.h"
00014 
00015 class TrTrack;
00016 
00017 static const InterfaceID IID_ITrExtrapolator( "ITrExtrapolator" , 1, 0 );
00018 
00031 class ITrExtrapolator: virtual public IAlgTool {
00032 public:
00034   static const InterfaceID& interfaceID() { return IID_ITrExtrapolator; }
00035 
00037   virtual StatusCode propagate( const TrTrack* track,
00038                                 double z,
00039                                 TrState* state,
00040                                 ParticleID& pid = ParticleID(211) );
00041 
00043   virtual StatusCode propagate( const TrTrack* track,
00044                                 const HepPlane3D& plane,
00045                                 TrState* state,
00046                                 ParticleID& pid = ParticleID(211) );
00047 
00049   virtual StatusCode propagate( TrState* state,
00050                                 double z,
00051                                 ParticleID& pid = ParticleID(211) ) = 0;
00052 
00054   virtual StatusCode propagate( TrState* state,
00055                                 const HepPlane3D& plane,
00056                                 ParticleID& pid = ParticleID(211) ) = 0;
00057 
00060   StatusCode positionAndMomentum( const TrTrack* track,
00061                                   double z,
00062                                   HepPoint3D& pos,
00063                                   HepVector3D& mom,
00064                                   HepSymMatrix& cov6D,
00065                                   ParticleID& pid = ParticleID(211) );
00066 
00069   StatusCode positionAndMomentum( const TrTrack* track,
00070                                   const HepPlane3D& plane,
00071                                   HepPoint3D& pos,
00072                                   HepVector3D& mom,
00073                                   HepSymMatrix& cov6D,
00074                                   ParticleID& pid = ParticleID(211) );
00075 
00077   StatusCode position( const TrTrack* track,
00078                        double z,
00079                        HepPoint3D& pos,
00080                        HepSymMatrix& errPos,
00081                        ParticleID& pid = ParticleID(211) );
00082 
00084   StatusCode position( const TrTrack* track,
00085                        const HepPlane3D& plane,
00086                        HepPoint3D& pos,
00087                        HepSymMatrix& errPos,
00088                        ParticleID& pid = ParticleID(211) );
00089 
00091   StatusCode slopes( const TrTrack* track,
00092                      double z,
00093                      HepVector3D& slopes,
00094                      HepSymMatrix& errSlopes,
00095                      ParticleID& pid = ParticleID(211) );
00096 
00098   StatusCode slopes( const TrTrack* track,
00099                      const HepPlane3D& plane,
00100                      HepVector3D& slopes,
00101                      HepSymMatrix& errSlopes,
00102                      ParticleID& pid = ParticleID(211) );
00103 
00105   StatusCode p( const TrTrack* track,
00106                 double z,
00107                 double& p,
00108                 ParticleID& pid = ParticleID(211) );
00109 
00111   StatusCode p( const TrTrack* track,
00112                 const HepPlane3D& plane,
00113                 double& p,
00114                 ParticleID& pid = ParticleID(211) );
00115 
00117   StatusCode pt( const TrTrack* track,
00118                  double z,
00119                  double& pt,
00120                  ParticleID& pid = ParticleID(211) );
00121 
00123   StatusCode pt( const TrTrack* track,
00124                  const HepPlane3D& plane,
00125                  double& pt,
00126                  ParticleID& pid = ParticleID(211) );
00127 
00129   StatusCode momentum( const TrTrack* track,
00130                        double z,
00131                        HepVector3D& mom,
00132                        HepSymMatrix& errMom,
00133                        ParticleID& pid = ParticleID(211) );
00134 
00136   StatusCode momentum( const TrTrack* track,
00137                        const HepPlane3D& plane,
00138                        HepVector3D& mom,
00139                        HepSymMatrix& errMom,
00140                        ParticleID& pid = ParticleID(211) );
00141 
00143   virtual const HepMatrix& transportMatrix() const = 0;
00144 
00145 };
00146 
00147 // -----------------------------------------------------------------------------
00148 //   end of class
00149 // -----------------------------------------------------------------------------
00150 
00151 inline StatusCode propagate( const TrTrack* track,
00152                              double z,
00153                              TrState* state,
00154                              ParticleID& pid = ParticleID(211) )
00155 {
00156   // check the track
00157   if ( !track ) {
00158      return Error( "propagate() should be called with a pointer to a TrTrack !",
00159                    StatusCode::FAILURE);
00160   }
00161 
00162   // get state closest to z
00163   const TrState* closest = track -> closestState( z );
00164   state = closest->clone();
00165 
00166   // propagate the closest state
00167   StatusCode sc = propagate( state, z, pid );
00168 
00169   return sc;
00170 }
00171 
00172 inline StatusCode propagate( const TrTrack* track,
00173                                 const HepPlane3D& plane,
00174                                 TrState* state,
00175                                 ParticleID& pid = ParticleID(211)
00176 {
00177   // check the track
00178   if ( !track ) {
00179      return Error( "propagate() should be called with a pointer to a TrTrack !",
00180                    StatusCode::FAILURE);
00181   }
00182 
00183   // get state closest to the plane
00184   const TrState* closest = track -> closestState( plane );
00185   state = closest->clone();
00186 
00187   // propagate the closest state
00188   StatusCode sc = propagate( state, plane, pid );
00189 
00190   return sc;
00191 }
00192 
00193 inline StatusCode propagate( TrState* state,
00194                                 const HepPlane3D& plane,
00195                                 ParticleID& pid = ParticleID(211)
00196 {
00197 
00198 }
00199 
00200 inline StatusCode ITrExtrapolator::positionAndMomentum( const TrTrack* track,
00201                                                         double z,
00202                                                         HepPoint3D& pos,
00203                                                         HepVector3D& mom,
00204                                                         HepSymMatrix& cov6D,
00205                                                         ParticleID& pid = ParticleID(211) )
00206 {
00207   TrState* tmpState = NULL;
00208 
00209   StatusCode sc = propagate( track, z, state, pid );
00210 
00211   if ( NULL != tmpState ) {
00212     tmpState -> positionAndMomentum( pos, mom, cov6D );
00213     return StatusCode::SUCCESS;
00214   }
00215   else {
00216     return StatusCode::FAILURE;
00217 }
00218 
00219 inline StatusCode ITrExtrapolator::positionAndMomentum( const TrTrack* track,
00220                                                         const HepPlane3D& plane,
00221                                                         HepPoint3D& pos,
00222                                                         HepVector3D& mom,
00223                                                         HepSymMatrix& cov6D,
00224                                                         ParticleID& pid = ParticleID(211) )
00225 {
00226 
00227   TrState* tmpState = NULL;
00228 
00229   StatusCode sc = propagate( track, plane, state, pid );
00230 
00231   if ( NULL != tmpState ) {
00232     tmpState -> positionAndMomentum( pos, mom, cov6D );
00233     return StatusCode::SUCCESS;
00234   }
00235   else {
00236     return StatusCode::FAILURE;
00237 }
00238 
00239 inline StatusCode ITrExtrapolator::position( const TrTrack* track,
00240                                              double z,
00241                                              HepPoint3D& pos,
00242                                              HepSymMatrix& errPos,
00243                                              ParticleID& pid = ParticleID(211) )
00244 
00245 {
00246   TrState* tmpState = NULL;
00247 
00248   StatusCode sc = propagate( track, z, pid );
00249 
00250   if ( NULL != tmpState ) {
00251     pos    = tmpState -> position();
00252     errPos = tmpState -> errPosition();
00253     return StatusCode::SUCCESS;
00254   }
00255   else {
00256     return StatusCode::FAILURE;
00257 }
00258 
00259 inline StatusCode ITrExtrapolator::position( const TrTrack* track,
00260                                              const HepPlane3D& plane,
00261                                              HepPoint3D& pos,
00262                                              HepSymMatrix& errPos,
00263                                              ParticleID& pid = ParticleID(211) )
00264 {
00265   TrState* tmpState = NULL;
00266 
00267   StatusCode sc = propagate( track, plane, pid );
00268 
00269   if ( NULL != tmpState ) {
00270     pos    = tmpState -> position();
00271     errPos = tmpState -> errPosition();
00272     return StatusCode::SUCCESS;
00273   }
00274   else {
00275     return StatusCode::FAILURE;
00276 }
00277 
00278 inline StatusCode ITrExtrapolator::slopes( const TrTrack* track,
00279                                            double z,
00280                                            HepVector3D& slopes,
00281                                            HepSymMatrix& errSlopes,
00282                                            ParticleID& pid = ParticleID(211) )
00283 {
00284   TrState* tmpState = NULL;
00285 
00286   StatusCode sc = propagate( track, z, pid );
00287 
00288   if ( NULL != tmpState ) {
00289     slopes    = tmpState -> slopes();
00290     errSlopes = tmpState -> errSlopes();
00291     return StatusCode::SUCCESS;
00292   }
00293   else {
00294     return StatusCode::FAILURE;
00295 }
00296 
00297 inline StatusCode ITrExtrapolator::slopes( const TrTrack* track,
00298                                            const HepPlane3D& plane,
00299                                            HepVector3D& slopes,
00300                                            HepSymMatrix& errSlopes,
00301                                            ParticleID& pid = ParticleID(211) )
00302 {
00303   TrState* tmpState = NULL;
00304 
00305   StatusCode sc = propagate( track, plane, pid );
00306 
00307   if ( NULL != tmpState ) {
00308     slopes    = tmpState -> slopes();
00309     errSlopes = tmpState -> errSlopes();
00310     return StatusCode::SUCCESS;
00311   }
00312   else {
00313     return StatusCode::FAILURE;
00314 }
00315 
00316 inline StatusCode ITrExtrapolator::p( const TrTrack* track,
00317                                       double z,
00318                                       double& p,
00319                                       ParticleID& pid = ParticleID(211) )
00320 {
00321   TrState* tmpState = NULL;
00322 
00323   StatusCode sc = propagate( track, z, pid );
00324 
00325   if ( NULL != tmpState ) {
00326     p = tmpState -> p();
00327     return StatusCode::SUCCESS;
00328   }
00329   else {
00330     return StatusCode::FAILURE;
00331 }
00332 
00333 inline StatusCode ITrExtrapolator::p( const TrTrack* track,
00334                                       const HepPlane3D& plane,
00335                                       double& p,
00336                                       ParticleID& pid = ParticleID(211) )
00337 {
00338   TrState* tmpState = NULL;
00339 
00340   StatusCode sc = propagate( track, plane, pid );
00341 
00342   if ( NULL != tmpState ) {
00343     p = tmpState -> p();
00344     return StatusCode::SUCCESS;
00345   }
00346   else {
00347     return StatusCode::FAILURE;
00348 }
00349 
00350 inline StatusCode ITrExtrapolator::pt( const TrTrack* track,
00351                                        double z,
00352                                        double& pt,
00353                                        ParticleID& pid = ParticleID(211) )
00354 {
00355   TrState* tmpState = NULL;
00356 
00357   StatusCode sc = propagate( track, z, pid );
00358 
00359   if ( NULL != tmpState ) {
00360     pt = tmpState -> pt();
00361     return StatusCode::SUCCESS;
00362   }
00363   else {
00364     return StatusCode::FAILURE;
00365 }
00366 
00367 inline StatusCode ITrExtrapolator::pt( const TrTrack* track,
00368                                        const HepPlane3D& plane,
00369                                        double& pt,
00370                                        ParticleID& pid = ParticleID(211) )
00371 {
00372   TrState* tmpState = NULL;
00373 
00374   StatusCode sc = propagate( track, plane, pid );
00375 
00376   if ( NULL != tmpState ) {
00377     pt = tmpState -> pt();
00378     return StatusCode::SUCCESS;
00379   }
00380   else {
00381     return StatusCode::FAILURE;
00382 }
00383 
00384 inline StatusCode ITrExtrapolator::momentum( const TrTrack* track,
00385                                              double z,
00386                                              HepVector3D& mom,
00387                                              HepSymMatrix& errMom,
00388                                              ParticleID& pid = ParticleID(211) )
00389 {
00390   TrState* tmpState = NULL;
00391 
00392   StatusCode sc = propagate( track, z, pid );
00393 
00394   if ( NULL != tmpState ) {
00395     mom    = tmpState -> momentum();
00396     errMom = tmpState -> errMomentum();
00397     return StatusCode::SUCCESS;
00398   }
00399   else {
00400     return StatusCode::FAILURE;
00401 }
00402 
00403 inline StatusCode ITrExtrapolator::momentum( const TrTrack* track,
00404                                              const HepPlane3D& plane,
00405                                              HepVector3D& mom,
00406                                              HepSymMatrix& errMom,
00407                                              ParticleID& pid = ParticleID(211) )
00408 {
00409   TrState* tmpState = NULL;
00410 
00411   StatusCode sc = propagate( track, plane, pid );
00412 
00413   if ( NULL != tmpState ) {
00414     mom    = tmpState -> momentum();
00415     errMom = tmpState -> errMomentum();
00416     return StatusCode::SUCCESS;
00417   }
00418   else {
00419     return StatusCode::FAILURE;
00420 }
00421 
00422 #endif // TRKERNEL_ITREXTRAPOLATOR_H