P4Helpers Namespace Reference

P4Helpers provides static helper functions for kinematic calculation on objects deriving from I4Momentum. More...

Functions
double	deltaPhi (double phiA, double phiB)
	delta Phi in range [-pi,pi[
template<class Iterator_t, class Predicate_t>
void	sort (Iterator_t itr, Iterator_t itrEnd, Predicate_t p)
	sort a container according to the given predicate
template<class Container_t, class Predicate_t>
void	sort (Container_t &container, Predicate_t p)
	sort a container according to the given predicate
double	deltaEta (const I4Momentum &p1, const I4Momentum &p2)
	Computes efficiently \( \Delta{\eta} \).
double	deltaEtaSq (const I4Momentum &p1, const I4Momentum &p2)
	Computes efficiently \( \Delta{\eta}^2 \).
double	deltaEta (const I4Momentum *const p1, const I4Momentum *const p2)
	Computes efficiently \( \Delta{\eta} \), pointer args.
double	deltaPhi (const I4Momentum &p4, const double phi)
	delta Phi in range [-pi,pi[ from one I4momentum reference
double	deltaPhi (const I4Momentum &pA, const I4Momentum &pB)
	delta Phi in range [-pi,pi[ from two I4momentum references
double	deltaPhiSq (const I4Momentum &pA, const I4Momentum &pB)
	delta Phi squared in range ([-pi,pi[)^2 from two I4momentum references
double	deltaPhi (const I4Momentum *const pA, const I4Momentum *const pB)
	delta Phi in range [-pi,pi[ from two I4momentum pointers
double	deltaR (const I4Momentum &p4, double eta, double phi)
	\( \Delta{R} \) from 1 I4Momentum
double	deltaR (const I4Momentum &pA, const I4Momentum &pB)
	delta R from two I4momentum reference
double	deltaR (const I4Momentum *const pA, const I4Momentum *const pB)
	delta R from two I4momentum pointers
bool	isInDeltaR (const I4Momentum &p1, const I4Momentum &p2, double dR)
	Check if 2 I4Momentum are in a \( \Delta{R} \) cone.
double	invMass (const I4Momentum &pA, const I4Momentum &pB)
	invariant mass from two I4momentum references
double	invMass (const I4Momentum *const pA, const I4Momentum *const pB)
	invariant mass from two I4momentum pointers
double	invMass (const I4Momentum &pA, const I4Momentum &pB, const I4Momentum &pC, const I4Momentum &pD)
	invariant mass from four I4momentum references
double	invMass (const I4Momentum *const pA, const I4Momentum *const pB, const I4Momentum *const pC, const I4Momentum *const pD)
	invariant mass from four I4momentum pointers

Detailed Description

P4Helpers provides static helper functions for kinematic calculation on objects deriving from I4Momentum.

Author

David Rousseau rouss.nosp@m.eau@.nosp@m.lal.i.nosp@m.n2p3.nosp@m..fr

Sebastien Binet binet.nosp@m.@cer.nosp@m.n.ch

Tadashi Maeno

Function Documentation

deltaEta() [1/2]

double P4Helpers::deltaEta ( const I4Momentum & p1, const I4Momentum & p2 )

inline

Computes efficiently \( \Delta{\eta} \).

Definition at line 66 of file P4Helpers.h.

  {
    double dEta(999);
    if ( p1.kind() == I4Momentum::P4PXPYPZE && p2.kind() == I4Momentum::P4PXPYPZE )
      {
        const double mom1 = p1.p(); const double pz1 = p1.pz();
        const double mom2 = p2.p(); const double pz2 = p2.pz();
        if ( ( mom1 + pz1 ) * ( mom2 - pz2 ) > 0 )
          dEta = -0.5 * std::log(   ( mom1 - pz1 ) / ( mom1 + pz1 )
                                    * ( mom2 + pz2 ) / ( mom2 - pz2 ) );
      }
    else if ( p1.kind() == I4Momentum::P4PXPYPZE )
      {
        const double mom1 = p1.p(); const double pz1 = p1.pz();
        if ( mom1 + pz1 > 0 )
          dEta = -0.5 * std::log(   ( mom1 - pz1 ) / ( mom1 + pz1 ) ) - p2.eta();
      }
    else if ( p2.kind() == I4Momentum::P4PXPYPZE )
      {
        const double mom2 = p2.p(); const double pz2 = p2.pz();
        if ( mom2 - pz2 > 0 )
          dEta = p1.eta() - 0.5 * std::log(  ( mom2 + pz2 ) / ( mom2 - pz2 ) );
      }
    else
      {
        dEta = p1.eta() - p2.eta();
      }
    return dEta;
  }

deltaEta() [2/2]

double P4Helpers::deltaEta ( const I4Momentum *const p1, const I4Momentum *const p2 )

inline

Computes efficiently \( \Delta{\eta} \), pointer args.

Definition at line 140 of file P4Helpers.h.

  {
    return deltaEta(*p1, *p2);
  }

deltaEtaSq()

double P4Helpers::deltaEtaSq ( const I4Momentum & p1, const I4Momentum & p2 )

inline

Computes efficiently \( \Delta{\eta}^2 \).

Definition at line 98 of file P4Helpers.h.

  {
    double dEtaSq(999);
    if ( p1.kind() == I4Momentum::P4PXPYPZE && p2.kind() == I4Momentum::P4PXPYPZE )
      {
        const double mom1 = p1.p(); const double pz1 = p1.pz();
        const double mom2 = p2.p(); const double pz2 = p2.pz();
        if ( ( mom1 + pz1 ) * ( mom2 - pz2 ) > 0 )
          {
            dEtaSq = std::log( ( mom1 - pz1 ) / ( mom1 + pz1 )
                               * ( mom2 + pz2 ) / ( mom2 - pz2 ) );
            dEtaSq = 0.25 * dEtaSq * dEtaSq;
          }
      }
    else if ( p1.kind() == I4Momentum::P4PXPYPZE )
      {
        const double mom1 = p1.p(); const double pz1 = p1.pz();
        if ( mom1 + pz1 > 0 )
          {
            dEtaSq = - 0.5 * std::log(   ( mom1 - pz1 ) / ( mom1 + pz1 ) ) - p2.eta();
            dEtaSq = dEtaSq * dEtaSq;
          }
      }
    else if ( p2.kind() == I4Momentum::P4PXPYPZE )
      {
        const double mom2 = p2.p(); const double pz2 = p2.pz();
        if ( mom2 - pz2 > 0 )
          {
            dEtaSq = p1.eta() - 0.5 * std::log(  ( mom2 + pz2 ) / ( mom2 - pz2 ) );
            dEtaSq = dEtaSq * dEtaSq;
          }
      }
    else
      {
        dEtaSq = p1.eta() - p2.eta();
        dEtaSq = dEtaSq * dEtaSq;
      }
    return dEtaSq;
  }

deltaPhi() [1/4]

double P4Helpers::deltaPhi ( const I4Momentum & p4, const double phi )

inline

delta Phi in range [-pi,pi[ from one I4momentum reference

Definition at line 147 of file P4Helpers.h.

  {
    return P4Helpers::deltaPhi( p4.phi(), phi );
  }

deltaPhi() [2/4]

double P4Helpers::deltaPhi ( const I4Momentum & pA, const I4Momentum & pB )

inline

delta Phi in range [-pi,pi[ from two I4momentum references

Definition at line 154 of file P4Helpers.h.

  {
    double dPhi(999);
    if ( pA.kind() == I4Momentum::P4PXPYPZE && pB.kind() == I4Momentum::P4PXPYPZE )
      {
        double xp = pA.px() * pB.px() ;
        double xyp1 = 0;
        if ( xp != 0 )
          {
            xyp1 = 1.0 + pA.py() * pB.py() / xp ;
            dPhi = 0;
            if ( xyp1 != 0 )
              dPhi = atan( ( pA.py() / pA.px() - pB.py() / pB.px() ) / xyp1 );
            if ( xyp1 < 0 )
              {
                if ( pA.py() / pA.px() > 0 )
                  dPhi += M_PI;
                else
                  dPhi -= M_PI;
              }
          }
      }
    else
      {
        dPhi = remainder( -pA.phi() + pB.phi(), 2*M_PI );
      }
    return dPhi;
  }

deltaPhi() [3/4]

double P4Helpers::deltaPhi ( const I4Momentum *const pA, const I4Momentum *const pB )

inline

delta Phi in range [-pi,pi[ from two I4momentum pointers

Definition at line 204 of file P4Helpers.h.

  { return deltaPhi( pA->phi(), pB->phi() ); }

deltaPhi() [4/4]

double P4Helpers::deltaPhi ( double phiA, double phiB )

inline

delta Phi in range [-pi,pi[

Definition at line 34 of file P4Helpers.h.

                                                 {
  return -remainder(-phiA + phiB, 2 * M_PI);
}

deltaPhiSq()

double P4Helpers::deltaPhiSq ( const I4Momentum & pA, const I4Momentum & pB )

inline

delta Phi squared in range ([-pi,pi[)^2 from two I4momentum references

Definition at line 185 of file P4Helpers.h.

  {
    double dPhiSq(999);
    if ( pA.kind() == I4Momentum::P4PXPYPZE && pB.kind() == I4Momentum::P4PXPYPZE )
      {
        double cosPhi = ( pA.px() * pB.px() + pA.py() * pB.py() ) / pA.pt() / pB.pt();
        double phi = acos(cosPhi);
        dPhiSq = phi*phi;
      }
    else
      {
        dPhiSq = remainder( -pA.phi() + pB.phi(), 2*M_PI );
        dPhiSq = dPhiSq * dPhiSq;
      }
    return dPhiSq;
  }

deltaR() [1/3]

double P4Helpers::deltaR ( const I4Momentum & p4, double eta, double phi )

inline

\( \Delta{R} \) from 1 I4Momentum

Definition at line 209 of file P4Helpers.h.

  {
    using std::sqrt;
    const double dEta = p4.eta() - eta;
    const double dPhi = P4Helpers::deltaPhi( p4, phi );
    return sqrt( dEta*dEta + dPhi*dPhi );
  }

deltaR() [2/3]

double P4Helpers::deltaR ( const I4Momentum & pA, const I4Momentum & pB )

inline

delta R from two I4momentum reference

Definition at line 219 of file P4Helpers.h.

  {
    using std::sqrt;
    const double dEtaSq = P4Helpers::deltaEtaSq( pA, pB );
    const double dPhiSq = P4Helpers::deltaPhiSq( pA, pB );
    return sqrt( dEtaSq + dPhiSq );
  }

deltaR() [3/3]

double P4Helpers::deltaR ( const I4Momentum *const pA, const I4Momentum *const pB )

inline

delta R from two I4momentum pointers

Definition at line 229 of file P4Helpers.h.

  { return P4Helpers::deltaR( *pA, *pB ); }

invMass() [1/4]

double P4Helpers::invMass ( const I4Momentum & pA, const I4Momentum & pB )

inline

invariant mass from two I4momentum references

Definition at line 252 of file P4Helpers.h.

  { return (pA.hlv()+pB.hlv()).m(); }

invMass() [2/4]

double P4Helpers::invMass ( const I4Momentum & pA, const I4Momentum & pB, const I4Momentum & pC, const I4Momentum & pD )

inline

invariant mass from four I4momentum references

Definition at line 262 of file P4Helpers.h.

  { return (pA.hlv()+pB.hlv()+pC.hlv()+pD.hlv()).m(); }

invMass() [3/4]

double P4Helpers::invMass ( const I4Momentum *const pA, const I4Momentum *const pB )

inline

invariant mass from two I4momentum pointers

Definition at line 257 of file P4Helpers.h.

  { return invMass( *pA, *pB ); }

invMass() [4/4]

double P4Helpers::invMass ( const I4Momentum *const pA, const I4Momentum *const pB, const I4Momentum *const pC, const I4Momentum *const pD )

inline

invariant mass from four I4momentum pointers

Definition at line 268 of file P4Helpers.h.

  { return invMass( *pA, *pB, *pC, *pD ); }

isInDeltaR()

bool P4Helpers::isInDeltaR ( const I4Momentum & p1, const I4Momentum & p2, double dR )

inline

Check if 2 I4Momentum are in a \( \Delta{R} \) cone.

Parameters

dR	[in] \( \Delta{R} \)

Returns

true if they are

Definition at line 236 of file P4Helpers.h.

  {
    using std::abs;
    using std::sqrt;
    const double dPhi = abs( P4Helpers::deltaPhi(p1,p2) ); // in [-pi,pi)
    if ( dPhi > dR ) return false;                         // <==
    const double dEta = abs( P4Helpers::deltaEta(p1,p2) );
    if ( dEta > dR ) return false;                         // <==
    const double deltaR2 = dEta*dEta + dPhi*dPhi;
    if ( deltaR2 > dR*dR ) return false;                   // <==
    return true;
  }

sort() [1/2]

template<class Container_t, class Predicate_t>

void P4Helpers::sort ( Container_t & container, Predicate_t p )

inline

sort a container according to the given predicate

Definition at line 49 of file P4Helpers.h.

                                                        {
  return P4Helpers::sort(container.begin(), container.end(), p);
}

sort() [2/2]

template<class Iterator_t, class Predicate_t>

void P4Helpers::sort ( Iterator_t itr, Iterator_t itrEnd, Predicate_t p )

inline

sort a container according to the given predicate

Definition at line 40 of file P4Helpers.h.

                                                                   {
  // Koenig's look-up at our rescue: handle correctly DataVector's
  // special sort method. => We inject the std::sort into our namespace
  using std::sort;
  return sort(itr, itrEnd, p);
}