In This Package:

Kinematics.h

Go to the documentation of this file.

// $Id: Kinematics.h,v 1.2 2008/12/02 15:54:30 ibelyaev Exp $
// ============================================================================
#ifndef LHCBMATH_KINEMATICS_H 
#define LHCBMATH_KINEMATICS_H 1
// ============================================================================
// Include files
// ============================================================================
// ROOT
// ============================================================================
#include "Math/SMatrix.h"
#include "Math/SVector.h"
#include "Math/Vector4D.h"
// ============================================================================
namespace Gaudi
{
  // ==========================================================================
  namespace Math 
  {   
    // ========================================================================
    template <class C, class T>
    inline double
    sigma2mass2 
    ( const ROOT::Math::LorentzVector<C>&                           momentum   , 
      const ROOT::Math::SMatrix<T,4,4,ROOT::Math::MatRepSym<T,4> >& covariance ) 
    {
      // get the vector d(M2)/dp_i :
      ROOT::Math::SVector<T,4> dM2dp;
      dM2dp [0] = -2 * momentum.Px () ;
      dM2dp [1] = -2 * momentum.Py () ;
      dM2dp [2] = -2 * momentum.Pz () ;
      dM2dp [3] =  2 * momentum.E  () ;
      //
      return ROOT::Math::Similarity ( covariance , dM2dp ) ;
    }
    // ========================================================================
    template <class C, class T>
    inline double
    sigma2mass 
    ( const ROOT::Math::LorentzVector<C>&                           momentum   , 
      const ROOT::Math::SMatrix<T,4,4,ROOT::Math::MatRepSym<T,4> >& covariance ) 
    {
      const double s2m2 = sigma2mass2( momentum , covariance ) ;
      const double m2   = momentum.M2 () ;
      if ( 0 < m2 ) { return 0.25 * s2m2 / m2 ; }
      return -1000000 ;                                          // RETURN 
    }
    // ========================================================================
    template <class C, class T>
    inline double
    sigmamass 
    ( const ROOT::Math::LorentzVector<C>&                           momentum   , 
      const ROOT::Math::SMatrix<T,4,4,ROOT::Math::MatRepSym<T,4> >& covariance ) 
    {
      const double s2m = sigma2mass ( momentum , covariance ) ;
      if ( 0 < s2m ) { return ::sqrt ( s2m ) ; }
      return s2m ;
    }
    // ========================================================================
    template <class C, class T>
    inline double chi2mass 
    ( const double                                                  mass       , 
      const ROOT::Math::LorentzVector<C>&                           momentum   , 
      const ROOT::Math::SMatrix<T,4,4,ROOT::Math::MatRepSym<T,4> >& covariance ) 
    {
      // sigma^2(M^2):
      const double s2 = 1.0 / Gaudi::Math::sigma2mass2 ( momentum , covariance ) ;
      // delta(M^2)
      const double dm2 = momentum.M2() - mass * mass ;
      //  (delta^2(M^2))/(sigma^2(M^2))
      return ( dm2 * dm2 ) * s2 ;
    }
    // ========================================================================
  } // end of namespace Gaudi::Math
  // ==========================================================================
} // end of namespace Gaudi
// ============================================================================
// The END
// ============================================================================
#endif // LHCBMATH_KINEMATICS_H
// ============================================================================

---