LHCbMath: /home/dayabay/installs/trunk_2011_04_11_opt/NuWa-trunk/lhcb/Kernel/LHCbMath/LHCbMath/MatrixTransforms.h Source File

00001 // $Id: MatrixTransforms.h,v 1.5 2008/05/22 13:45:39 cattanem Exp $
00002 // ============================================================================
00003 #ifndef LHCBMATH_MATRIXTRANSFORMS_H 
00004 #define LHCBMATH_MATRIXTRANSFORMS_H 1
00005 // ============================================================================
00006 // Include files
00007 // ============================================================================
00008 // ROOT
00009 // ============================================================================
00010 #include "Math/SMatrix.h"
00011 #include "Math/SVector.h"
00012 #include "Math/Point3D.h"
00013 #include "Math/Vector4D.h"
00014 #include "Math/Vector3D.h"
00015 // ============================================================================
00034 // ============================================================================
00035 namespace Gaudi
00036 {
00037   namespace Math 
00038   {   
00039     // ========================================================================
00058     template <class C,class T>
00059     inline 
00060     const ROOT::Math::SVector<T,3>& 
00061     geo2LA
00062     ( const ROOT::Math::PositionVector3D<C>& source , 
00063       ROOT::Math::SVector<T,3>&              dest   ) 
00064     {
00065       dest ( 0 ) = source.X () ;
00066       dest ( 1 ) = source.Y () ;
00067       dest ( 2 ) = source.Z () ;
00068       return dest ;
00069     } 
00070     // ========================================================================
00089     template <class C,class T>
00090     inline 
00091     const ROOT::Math::SVector<T,3>& 
00092     geo2LA 
00093     ( const ROOT::Math::DisplacementVector3D<C>& source , 
00094       ROOT::Math::SVector<T,3>&                  dest   ) 
00095     {
00096       dest ( 0 ) = source.X () ;
00097       dest ( 1 ) = source.Y () ;
00098       dest ( 2 ) = source.Z () ;
00099       return dest ;
00100     }
00101     // ========================================================================
00120     template <class C,class T>
00121     inline 
00122     const ROOT::Math::SVector<T,4>& 
00123     geo2LA 
00124     ( const ROOT::Math::LorentzVector<C>& source , 
00125       ROOT::Math::SVector<T,4>&           dest  ) 
00126     {
00127       dest ( 0 ) = source.X () ;
00128       dest ( 1 ) = source.Y () ;
00129       dest ( 2 ) = source.Z () ;
00130       dest ( 3 ) = source.E () ;
00131       return dest ;
00132     } 
00133     // ========================================================================
00153     template <class C,class T>
00154     inline 
00155     const ROOT::Math::SVector<T,3>& 
00156     geo2LA 
00157     ( const ROOT::Math::LorentzVector<C>& source , 
00158       ROOT::Math::SVector<T,3>&           dest  ) 
00159     {
00160       dest ( 0 ) = source.X () ;
00161       dest ( 1 ) = source.Y () ;
00162       dest ( 2 ) = source.Z () ;
00163       return dest ;
00164     } 
00165     // ========================================================================
00184     template <class C,class T>
00185     inline 
00186     const ROOT::Math::PositionVector3D<C>&
00187     la2geo 
00188     ( const ROOT::Math::SVector<T,3>&  source , 
00189       ROOT::Math::PositionVector3D<C>& dest   ) 
00190     {
00191       dest.SetX ( source ( 0 ) ) ;      
00192       dest.SetY ( source ( 1 ) ) ;
00193       dest.SetZ ( source ( 2 ) ) ;
00194       return dest ;
00195     } 
00196     // ========================================================================
00215     template <class C,class T>
00216     inline 
00217     const ROOT::Math::DisplacementVector3D<C>&
00218     la2geo 
00219     ( const ROOT::Math::SVector<T,3>&      source , 
00220       ROOT::Math::DisplacementVector3D<C>& dest   ) 
00221     {
00222       dest.SetX ( source ( 0 ) ) ;      
00223       dest.SetY ( source ( 1 ) ) ;
00224       dest.SetZ ( source ( 2 ) ) ;
00225       return dest ;
00226     } 
00227     // ========================================================================
00246     template <class C,class T>
00247     inline 
00248     const ROOT::Math::LorentzVector<C>&  
00249     la2geo 
00250     ( const ROOT::Math::SVector<T,4>& source , 
00251       ROOT::Math::LorentzVector<C>&   dest   )  
00252     {
00253       dest.SetPx ( source ( 0 ) ) ;
00254       dest.SetPy ( source ( 1 ) ) ;
00255       dest.SetPz ( source ( 2 ) ) ;
00256       dest.SetE  ( source ( 3 ) ) ;
00257       return dest ;
00258     }
00259     // ========================================================================
00286     template <class C,class T>
00287     inline T 
00288     Similarity
00289     ( const ROOT::Math::DisplacementVector3D<C>&                     delta  , 
00290       const ROOT::Math::SMatrix<T,3,3,ROOT::Math::MatRepSym<T,3> > & matrix ) 
00291     {
00292       ROOT::Math::SVector<T,3> tmp ;
00293       return ROOT::Math::Similarity ( geo2LA ( delta , tmp )  , matrix ) ;
00294     } 
00295     // ========================================================================
00322     template <class C,class T>
00323     inline T 
00324     Similarity
00325     ( const ROOT::Math::SMatrix<T,3,3,ROOT::Math::MatRepSym<T,3> > & matrix , 
00326       const ROOT::Math::DisplacementVector3D<C>&                     delta  ) 
00327     { return Similarity ( delta , matrix ) ; }
00328     // ========================================================================
00355     template <class C,class T>
00356     inline T 
00357     Similarity
00358     ( const ROOT::Math::LorentzVector<C>&                            delta  , 
00359       const ROOT::Math::SMatrix<T,4,4,ROOT::Math::MatRepSym<T,4> > & matrix ) 
00360     {
00361       ROOT::Math::SVector<T,4> tmp ;
00362       return ROOT::Math::Similarity ( geo2LA( delta , tmp ) , matrix ) ;
00363     }
00364     // ========================================================================
00391     template <class C,class T>
00392     inline T 
00393     Similarity
00394     ( const ROOT::Math::SMatrix<T,4,4,ROOT::Math::MatRepSym<T,4> > & matrix ,
00395       const ROOT::Math::LorentzVector<C>&                            delta  ) 
00396     { return Similarity ( delta , matrix ) ; } 
00397     // ========================================================================
00416     template <class C, class T>
00417     inline 
00418     const ROOT::Math::LorentzVector<C>& 
00419     add 
00420     ( ROOT::Math::LorentzVector<C>& v1 , const ROOT::Math::SVector<T,4> & v2 ) 
00421     { return v1 += ROOT::Math::LorentzVector<C>
00422         ( v2 ( 0 )  , v2 ( 1 )  , v2 ( 2 ) , v2 ( 3 ) ) ; }
00423     // ========================================================================    
00442     template <class T1,class T2,unsigned int D, class R>
00443     inline 
00444     ROOT::Math::SMatrix<T1,D,D,ROOT::Math::MatRepSym<T1,D> >& 
00445     add
00446     ( ROOT::Math::SMatrix<T1,D,D,ROOT::Math::MatRepSym<T1,D> >& matrix , 
00447       const ROOT::Math::SMatrix<T2,D,D,R>&                      other  ) 
00448     {
00449       for   ( unsigned int i = 0 ; i < D ; ++i ) 
00450       { for ( unsigned int j = i ; j < D ; ++j ) { matrix(i,j) += other(i,j); } }
00451       return matrix ;
00452     }
00453     // ========================================================================
00469     template<class T, class C, class M>
00470     inline 
00471     const ROOT::Math::LorentzVector<C>&
00472     geo2LA 
00473     ( const ROOT::Math::SVector<T, 3>& source , 
00474       const M                          mass   ,
00475       ROOT::Math::LorentzVector<C>&    dest   ) 
00476     {
00477       // first calculate momentum in carthesian coordinates:
00478       const double p = 1/fabs(source(2)) ;
00479       const double n = sqrt( 1 + source(0)*source(0)+source(1)*source(1)) ;
00480       const double pz = p/n          ;
00481       const double px = pz*source(0) ;
00482       const double py = pz*source(1) ;
00483       dest.SetPx ( px ) ;
00484       dest.SetPy ( py ) ;
00485       dest.SetPz ( pz ) ;
00486       dest.SetE  ( std::sqrt ( p*p + mass*mass ) ) ;
00487       return dest ;
00488     }
00489     // ========================================================================
00514     template <class T,class R, class M >
00515     inline void  JacobdP4dMom 
00516     ( const ROOT::Math::SVector<T,3>& mom  ,
00517       const M                         mass , 
00518       ROOT::Math::SMatrix<R,4,3>&     J    )
00519     {
00520       double tx = mom(0) ;
00521       double ty = mom(1) ;
00522       double qop = mom(2) ;
00523       double p  = 1/fabs(qop) ;
00524       double n2 = 1 + tx*tx + ty*ty ;
00525       double n  = std::sqrt(n2) ;
00526       double n3 = n2*n ;
00527       double px = p*tx/n ;
00528       double py = p*ty/n ;
00529       double pz = p/n ;
00530       double E = sqrt(p*p+mass*mass) ;
00531       
00532       J(0,0) = p * (1+ty*ty)/n3 ; // dpx/dtx
00533       J(0,1) = p * tx * -ty/n3  ; // dpx/dty
00534       J(0,2) = -px/qop ;          // dpx/dqop
00535 
00536       J(1,0) = p * ty * -tx/n3  ; // dpy/dtx
00537       J(1,1) = p * (1+tx*tx)/n3 ; // dpy/dty
00538       J(1,2) = -py/qop ;          // dpy/dqop
00539 
00540       J(2,0) = pz * -tx/n2 ;      // dpz/dtx
00541       J(2,1) = pz * -ty/n2 ;      // dpz/dtx
00542       J(2,2) = -pz/qop ;          // dpz/dqop
00543       
00544       J(3,0) = 0.0          ;     // dE/dtx 
00545       J(3,1) = 0.0          ;     // dE/dty 
00546       J(3,2) = p/E * -p/qop ;     // dE/dqop
00547       
00548       return ; 
00549     }
00550     // ========================================================================
00551   } // end of namespace Gaudi::Math
00552 } // end of namespace Gaudi
00553 // ============================================================================
00554 namespace Gaudi
00555 {
00556   namespace Math 
00557   {
00558     // ========================================================================
00825     namespace Operators 
00826     {
00827       // ======================================================================
00846       template <class C, class T>
00847       inline 
00848       ROOT::Math::PositionVector3D<C>
00849       operator+ 
00850       ( const ROOT::Math::PositionVector3D<C>& p1 ,
00851         const ROOT::Math::SVector<T,3>&        v2 )
00852       {
00853         ROOT::Math::PositionVector3D<C> result  ;
00854         result.SetXYZ(  p1 . X () + v2 ( 0 ) , 
00855                         p1 . Y () + v2 ( 1 ) ,
00856                         p1 . Z () + v2 ( 2 ) ) ;
00857         return result ;
00858       }
00859       // ======================================================================
00860       template <class C, class B, class T>
00861       inline 
00862       ROOT::Math::PositionVector3D<C>
00863       operator+ 
00864       ( const ROOT::Math::PositionVector3D<C>& p1 ,
00865         const ROOT::Math::VecExpr<B,T,3>&      v2 )
00866       {
00867         ROOT::Math::PositionVector3D<C> result  ;
00868         result.SetXYZ(  p1 . X () + v2 ( 0 ) , 
00869                         p1 . Y () + v2 ( 1 ) ,
00870                         p1 . Z () + v2 ( 2 ) ) ;
00871         return result ;
00872       }
00873       // ========================================================================
00892       template <class C, class T>
00893       inline 
00894       ROOT::Math::DisplacementVector3D<C>
00895       operator+ 
00896       ( const ROOT::Math::DisplacementVector3D<C>& p1 ,
00897         const ROOT::Math::SVector<T,3>&            v2 )
00898       {
00899         ROOT::Math::PositionVector3D<C> result  ;
00900         result.SetXYZ(  p1 . X () + v2 ( 0 ) , 
00901                         p1 . Y () + v2 ( 1 ) ,
00902                         p1 . Z () + v2 ( 2 ) ) ;
00903         return result ;
00904       }
00905       // ======================================================================
00906       template <class C, class B, class T>
00907       inline 
00908       ROOT::Math::DisplacementVector3D<C>
00909       operator+ 
00910       ( const ROOT::Math::DisplacementVector3D<C>& p1 ,
00911         const ROOT::Math::VecExpr<B,T,3>&          v2 )
00912       {
00913         ROOT::Math::PositionVector3D<C> result  ;
00914         result.SetXYZ(  p1 . X () + v2 ( 0 ) , 
00915                         p1 . Y () + v2 ( 1 ) ,
00916                         p1 . Z () + v2 ( 2 ) ) ;
00917         return result ;
00918       }
00919       // ======================================================================
00938       template <class C, class T>
00939       inline 
00940       ROOT::Math::LorentzVector<C>
00941       operator+ 
00942       ( const ROOT::Math::LorentzVector<C>& p1 ,
00943         const ROOT::Math::SVector<T,4>&     v2 )
00944       {
00945         ROOT::Math::LorentzVector<C> result  ;
00946         result.SetXYZT 
00947           (  p1 . Px () + v2 ( 0 ) , 
00948              p1 . Py () + v2 ( 1 ) ,
00949              p1 . Pz () + v2 ( 2 ) ,
00950              p1 . E  () + v2 ( 3 ) ) ;
00951         return result ;
00952       }
00953       // ======================================================================
00954       template <class C, class B , class T>
00955       inline 
00956       ROOT::Math::LorentzVector<C>
00957       operator+ 
00958       ( const ROOT::Math::LorentzVector<C>& p1 ,
00959         const ROOT::Math::VecExpr<B,T,4>&   v2 )
00960       {
00961         ROOT::Math::LorentzVector<C> result  ;
00962         result.SetXYZT 
00963           (  p1 . Px () + v2 ( 0 ) , 
00964              p1 . Py () + v2 ( 1 ) ,
00965              p1 . Pz () + v2 ( 2 ) ,
00966              p1 . E  () + v2 ( 3 ) ) ;
00967         return result ;
00968       }
00969       // ======================================================================
00988       template <class C, class T>
00989       inline 
00990       ROOT::Math::SVector<T,3>
00991       operator+ 
00992       ( const ROOT::Math::SVector<T,3>&        v2 ,
00993         const ROOT::Math::PositionVector3D<C>& p1 )
00994       {
00995         ROOT::Math::SVector<T,3> result ( v2 ) ;
00996         result ( 0 ) += p1 . X () ;
00997         result ( 1 ) += p1 . Y () ;
00998         result ( 2 ) += p1 . Z () ;
00999         return result ;
01000       }
01001       // ======================================================================
01002       template <class C, class B, class T>
01003       inline 
01004       ROOT::Math::SVector<T,3>
01005       operator+ 
01006       ( const ROOT::Math::VecExpr<B,T,3>&      v2 ,
01007         const ROOT::Math::PositionVector3D<C>& p1 )
01008       {
01009         ROOT::Math::SVector<T,3> result = v2 ;
01010         result ( 0 ) += p1 . X () ;
01011         result ( 1 ) += p1 . Y () ;
01012         result ( 2 ) += p1 . Z () ;
01013         return result ;
01014       }
01015       // ======================================================================
01034       template <class C, class T>
01035       inline 
01036       ROOT::Math::SVector<T,3>
01037       operator+ 
01038       ( const ROOT::Math::SVector<T,3>&            v2 ,
01039         const ROOT::Math::DisplacementVector3D<C>& p1 )
01040       {
01041         ROOT::Math::SVector<T,3> result ( v2 ) ;
01042         result ( 0 ) += p1 . X () ;
01043         result ( 1 ) += p1 . Y () ;
01044         result ( 2 ) += p1 . Z () ;
01045         return result ;
01046       }
01047       // ======================================================================
01048       template <class C, class B, class T>
01049       inline 
01050       ROOT::Math::SVector<T,3>
01051       operator+ 
01052       ( const ROOT::Math::VecExpr<B,T,3>&          v2 ,
01053         const ROOT::Math::DisplacementVector3D<C>& p1 )
01054       {
01055         ROOT::Math::SVector<T,3> result = v2 ;
01056         result ( 0 ) += p1 . X () ;
01057         result ( 1 ) += p1 . Y () ;
01058         result ( 2 ) += p1 . Z () ;
01059         return result ;
01060       }
01061       // ======================================================================
01081       template <class C, class T>
01082       inline 
01083       ROOT::Math::SVector<T,4>
01084       operator+ 
01085       ( const ROOT::Math::SVector<T,4>&     v2 ,
01086         const ROOT::Math::LorentzVector<C>& p1 )
01087       {
01088         ROOT::Math::SVector<T,4> result ( v2 ) ;
01089         result ( 0 ) += p1 . Px () ;
01090         result ( 1 ) += p1 . Py () ;
01091         result ( 2 ) += p1 . Pz () ;
01092         result ( 3 ) += p1 . E  () ;
01093         return result ;
01094       }
01095       // ======================================================================
01096       template <class C, class B, class T>
01097       inline 
01098       ROOT::Math::SVector<T,4>
01099       operator+ 
01100       ( const ROOT::Math::VecExpr<B,T,4>&   v2 ,
01101         const ROOT::Math::LorentzVector<C>& p1 )
01102       {
01103         ROOT::Math::SVector<T,4> result = v2  ;
01104         result ( 0 ) += p1 . Px () ;
01105         result ( 1 ) += p1 . Py () ;
01106         result ( 2 ) += p1 . Pz () ;
01107         result ( 3 ) += p1 . E  () ;
01108         return result ;
01109       }
01110       // ======================================================================
01129       template <class C, class T>
01130       inline 
01131       ROOT::Math::PositionVector3D<C>
01132       operator- 
01133       ( const ROOT::Math::PositionVector3D<C>& p1 ,
01134         const ROOT::Math::SVector<T,3>&        v2 )
01135       {
01136         ROOT::Math::PositionVector3D<C> result  ;
01137         result.SetXYZ
01138           (  p1 . X () - v2 ( 0 ) , 
01139              p1 . Y () - v2 ( 1 ) ,
01140              p1 . Z () - v2 ( 2 ) ) ;
01141         return result ;
01142       }
01143      // ======================================================================
01144       template <class C, class B , class T>
01145       inline 
01146       ROOT::Math::PositionVector3D<C>
01147       operator- 
01148       ( const ROOT::Math::PositionVector3D<C>& p1 ,
01149         const ROOT::Math::VecExpr<B,T,3>&      v2 )
01150       {
01151         ROOT::Math::PositionVector3D<C> result  ;
01152         result.SetXYZ
01153           (  p1 . X () - v2 ( 0 ) , 
01154              p1 . Y () - v2 ( 1 ) ,
01155              p1 . Z () - v2 ( 2 ) ) ;
01156         return result ;
01157       }
01158       
01159       // ========================================================================
01178       template <class C, class T>
01179       inline 
01180       ROOT::Math::DisplacementVector3D<C>
01181       operator- 
01182       ( const ROOT::Math::DisplacementVector3D<C>& p1 ,
01183         const ROOT::Math::SVector<T,3>&            v2 )
01184       {
01185         ROOT::Math::PositionVector3D<C> result  ;
01186         result.SetXYZ
01187           (  p1 . X () - v2 ( 0 ) , 
01188              p1 . Y () - v2 ( 1 ) ,
01189              p1 . Z () - v2 ( 2 ) ) ;
01190         return result ;
01191       }
01192       // ======================================================================
01193       template <class C, class B, class T>
01194       inline 
01195       ROOT::Math::DisplacementVector3D<C>
01196       operator- 
01197       ( const ROOT::Math::DisplacementVector3D<C>& p1 ,
01198         const ROOT::Math::VecExpr<B,T,3>&          v2 )
01199       {
01200         ROOT::Math::PositionVector3D<C> result  ;
01201         result.SetXYZ
01202           (  p1 . X () - v2 ( 0 ) , 
01203              p1 . Y () - v2 ( 1 ) ,
01204              p1 . Z () - v2 ( 2 ) ) ;
01205         return result ;
01206       }      
01207       // ======================================================================
01226       template <class C, class T>
01227       inline 
01228       ROOT::Math::LorentzVector<C>
01229       operator- 
01230       ( const ROOT::Math::LorentzVector<C>& p1 ,
01231         const ROOT::Math::SVector<T,4>&     v2 )
01232       {
01233         ROOT::Math::LorentzVector<C> result  ;
01234         result.SetXYZT 
01235           (  p1 . Px () - v2 ( 0 ) , 
01236              p1 . Py () - v2 ( 1 ) ,
01237              p1 . Pz () - v2 ( 2 ) ,
01238              p1 . E  () - v2 ( 3 ) ) ;
01239         return result ;
01240       }
01241       // ======================================================================
01242       template <class C, class B, class T>
01243       inline 
01244       ROOT::Math::LorentzVector<C>
01245       operator- 
01246       ( const ROOT::Math::LorentzVector<C>& p1 ,
01247         const ROOT::Math::VecExpr<B,T,4>&   v2 )
01248       {
01249         ROOT::Math::LorentzVector<C> result  ;
01250         result.SetXYZT 
01251           (  p1 . Px () - v2 ( 0 ) , 
01252              p1 . Py () - v2 ( 1 ) ,
01253              p1 . Pz () - v2 ( 2 ) ,
01254              p1 . E  () - v2 ( 3 ) ) ;
01255         return result ;
01256       }
01257       // ======================================================================      
01272       template <class C, class T> 
01273       inline 
01274       ROOT::Math::SVector<T,4>
01275       operator- 
01276       ( const ROOT::Math::SVector<T,4>&     v1 , 
01277         const ROOT::Math::LorentzVector<C>& v2 ) 
01278       {
01279         ROOT::Math::SVector<T,4> result = v1 ;
01280         result ( 0 ) -= v2 . Px () ;
01281         result ( 1 ) -= v2 . Py () ;
01282         result ( 2 ) -= v2 . Pz () ;
01283         result ( 3 ) -= v2 . E  () ;
01284         return result ;
01285       }
01286       // ======================================================================
01287       template <class C, class B, class T> 
01288       inline 
01289       ROOT::Math::SVector<T,4>
01290       operator- 
01291       ( const ROOT::Math::VecExpr<B,T,4>&   v1 , 
01292         const ROOT::Math::LorentzVector<C>& v2 ) 
01293       {
01294         ROOT::Math::SVector<T,4> result = v1 ;
01295         result ( 0 ) -= v2 . Px () ;
01296         result ( 1 ) -= v2 . Py () ;
01297         result ( 2 ) -= v2 . Pz () ;
01298         result ( 3 ) -= v2 . E  () ;
01299         return result ;
01300       }
01301       // ======================================================================      
01316       template <class C, class T> 
01317       inline 
01318       ROOT::Math::SVector<T,3>
01319       operator- 
01320       ( const ROOT::Math::SVector<T,3>&        v1 , 
01321         const ROOT::Math::PositionVector3D<C>& v2 ) 
01322       {
01323         ROOT::Math::SVector<T,3> result = v1 ;
01324         result ( 0 ) -= v2 . X () ;
01325         result ( 1 ) -= v2 . Y () ;
01326         result ( 2 ) -= v2 . Z () ;
01327         return result ;
01328       }
01329       // ======================================================================
01330       template <class C, class B, class T> 
01331       inline 
01332       ROOT::Math::SVector<T,3>
01333       operator- 
01334       ( const ROOT::Math::VecExpr<B,T,3>&      v1 , 
01335         const ROOT::Math::PositionVector3D<C>& v2 ) 
01336       {
01337         ROOT::Math::SVector<T,3> result = v1 ;
01338         result ( 0 ) -= v2 . X () ;
01339         result ( 1 ) -= v2 . Y () ;
01340         result ( 2 ) -= v2 . Z () ;
01341         return result ;
01342       }
01343       // ======================================================================      
01358       template <class C, class T> 
01359       inline 
01360       ROOT::Math::SVector<T,3>
01361       operator- 
01362       ( const ROOT::Math::SVector<T,3>&            v1 , 
01363         const ROOT::Math::DisplacementVector3D<C>& v2 ) 
01364       {
01365         ROOT::Math::SVector<T,3> result = v1 ;
01366         result ( 0 ) -= v2 . X () ;
01367         result ( 1 ) -= v2 . Y () ;
01368         result ( 2 ) -= v2 . Z () ;
01369         return result ;
01370       }
01371       // ======================================================================
01372       template <class C, class B, class T> 
01373       inline 
01374       ROOT::Math::SVector<T,3>
01375       operator- 
01376       ( const ROOT::Math::VecExpr<B,T,3>&          v1 , 
01377         const ROOT::Math::DisplacementVector3D<C>& v2 ) 
01378       {
01379         ROOT::Math::SVector<T,3> result = v1 ;
01380         result ( 0 ) -= v2 . X () ;
01381         result ( 1 ) -= v2 . Y () ;
01382         result ( 2 ) -= v2 . Z () ;
01383         return result ;
01384       }
01385       // ======================================================================      
01400       template <class T, class C, class R, unsigned int D>
01401       inline 
01402       ROOT::Math::SVector<T,D>
01403       operator* 
01404       ( const ROOT::Math::SMatrix<T,D,4,R>& mrtx , 
01405         const ROOT::Math::LorentzVector<C>& vect ) 
01406       {
01407         const ROOT::Math::SVector<T,4> vct 
01408           ( vect . Px () , vect . Py () , vect . Pz () , vect.E () ) ;
01409         return mrtx * vct ;
01410       } 
01411       // ======================================================================
01412       template <class T, class C, class B, class R, unsigned int D>
01413       inline 
01414       ROOT::Math::SVector<T,D>
01415       operator* 
01416       ( const ROOT::Math::Expr<B,T,D,4,R>&  mtrx , 
01417         const ROOT::Math::LorentzVector<C>& vect ) 
01418       {
01419         const ROOT::Math::SVector<T,4> vct 
01420           ( vect . Px () , vect . Py () , vect . Pz () , vect.E () ) ;
01421         return mtrx * vct ;
01422       }
01423       // ======================================================================      
01438       template <class T, class C, class R, unsigned int D>
01439       inline 
01440       ROOT::Math::SVector<T,D>
01441       operator* 
01442       ( const ROOT::Math::LorentzVector<C>& vect , 
01443         const ROOT::Math::SMatrix<T,4,D,R>& mtrx )
01444       {
01445         const ROOT::Math::SVector<T,4> vct 
01446           ( vect . Px () , vect . Py () , vect . Pz () , vect.E () ) ;
01447         return vct * mtrx ;
01448       }
01449       // ======================================================================
01450       template <class T, class C, class B, class R, unsigned int D>
01451       inline 
01452       ROOT::Math::SVector<T,D>
01453       operator* 
01454       ( const ROOT::Math::LorentzVector<C>& vect , 
01455         const ROOT::Math::Expr<B,T,4,D,R>&  mtrx )
01456       {
01457         const ROOT::Math::SVector<T,4> vct 
01458           ( vect . Px () , vect . Py () , vect . Pz () , vect.E () ) ;
01459         return vct * mtrx ;
01460       }
01461       // ======================================================================      
01476       template <class T, class C, class R, unsigned int D>
01477       inline 
01478       ROOT::Math::SVector<T,D>
01479       operator* 
01480       ( const ROOT::Math::SMatrix<T,D,3,R>&        mtrx , 
01481         const ROOT::Math::DisplacementVector3D<C>& vect ) 
01482       {
01483         const ROOT::Math::SVector<T,3> vct 
01484           ( vect . X () , vect . Y () , vect . Z () ) ;
01485         return mtrx * vct ;
01486       } 
01487       // ======================================================================
01488       template <class T, class C, class B, class R, unsigned int D>
01489       inline 
01490       ROOT::Math::SVector<T,D>
01491       operator* 
01492       ( const ROOT::Math::Expr<B,T,D,3,R>&         mtrx , 
01493         const ROOT::Math::DisplacementVector3D<C>& vect ) 
01494       {
01495         const ROOT::Math::SVector<T,3> vct 
01496           ( vect . X () , vect . Y () , vect . Z () ) ;
01497         return mtrx * vct ;
01498       } 
01499       // ======================================================================      
01514       template <class T, class C, class R, unsigned int D>
01515       inline 
01516       ROOT::Math::SVector<T,D>
01517       operator* 
01518       ( const ROOT::Math::DisplacementVector3D<C>& vect , 
01519         const ROOT::Math::SMatrix<T,3,D,R>&        mtrx )
01520       {
01521         const ROOT::Math::SVector<T,3> vct 
01522           ( vect . X () , vect . Y () , vect . Z () ) ;
01523         return vct * mtrx ;
01524       }
01525       // ======================================================================      
01526       template <class T, class C, class B, class R, unsigned int D>
01527       inline 
01528       ROOT::Math::SVector<T,D>
01529       operator* 
01530       ( const ROOT::Math::DisplacementVector3D<C>& vect , 
01531         const ROOT::Math::Expr<B,T,3,D,R>&         mtrx )
01532       {
01533         const ROOT::Math::SVector<T,3> vct 
01534           ( vect . X () , vect . Y () , vect . Z () ) ;
01535         return vct * mtrx ;
01536       }
01537       // ======================================================================      
01552       template <class T, class C, class R, unsigned int D>
01553       inline 
01554       ROOT::Math::SVector<T,D>
01555       operator* 
01556       ( const ROOT::Math::SMatrix<T,D,3,R>&    mtrx , 
01557         const ROOT::Math::PositionVector3D<C>& vect ) 
01558       {
01559         const ROOT::Math::SVector<T,3> vct 
01560           ( vect . X () , vect . Y () , vect . Z () ) ;
01561         return mtrx * vct ;
01562       } 
01563       // ======================================================================      
01564       template <class T, class C, class B, class R, unsigned int D>
01565       inline 
01566       ROOT::Math::SVector<T,D>
01567       operator* 
01568       ( const ROOT::Math::Expr<B,T,D,3,R>&     mtrx , 
01569         const ROOT::Math::PositionVector3D<C>& vect ) 
01570       {
01571         const ROOT::Math::SVector<T,3> vct 
01572           ( vect . X () , vect . Y () , vect . X () ) ;
01573         return mtrx * vct ;
01574       } 
01575       // ======================================================================      
01590       template <class T, class C, class R, unsigned int D>
01591       inline 
01592       ROOT::Math::SVector<T,D>
01593       operator* 
01594       ( const ROOT::Math::PositionVector3D<C>& vect , 
01595         const ROOT::Math::SMatrix<T,3,D,R>&    mtrx )
01596       {
01597         const ROOT::Math::SVector<T,3> vct 
01598           ( vect . X () , vect . Y () , vect . Z () ) ;
01599         return vct * mtrx ;
01600       }
01601       // ======================================================================      
01602       template <class T, class C, class B, class R, unsigned int D>
01603       inline 
01604       ROOT::Math::SVector<T,D>
01605       operator* 
01606       ( const ROOT::Math::PositionVector3D<C>& vect , 
01607         const ROOT::Math::Expr<B,T,3,D,R>&     mtrx )
01608       {
01609         const ROOT::Math::SVector<T,3> vct 
01610           ( vect . X () , vect . Y () , vect . Z () ) ;
01611         return vct * mtrx ;
01612       }
01613       // ======================================================================
01614     } // end of namespace Gaudi::Math::OPerators
01615     // ========================================================================
01616   } // end of namespace Gaudi::Math
01617   // ==========================================================================
01618 } // end of namespace Gaudi::Math    
01619 // ============================================================================
01620 // The END
01621 // ============================================================================
01622 #endif // LHCBMATH_XXX_H
01623 // ============================================================================
In This Package:

MatrixTransforms.h
