/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/FourMomUtils/FourMomUtils/xAODP4Helpers.h

// P4Helpers.h
// Header file for P4 helper functions
// Author: karsten.koeneke@cern.ch
#ifndef FOURMOMUTILS_XAODP4HELPERS_H
#define FOURMOMUTILS_XAODP4HELPERS_H

// STL includes
#include <cmath>

// CxxUtils includes
#include "CxxUtils/fpcompare.h" // for fpcompare::less and greater

// EDM includes
#include "xAODBase/IParticle.h"
#include "xAODMissingET/MissingET.h"


namespace xAOD
{
  namespace P4Helpers
  {
    inline
    double deltaRapidity( const xAOD::IParticle& p1, const xAOD::IParticle& p2 )
    {
      return p1.rapidity() - p2.rapidity();
    }

    inline
    double deltaRapidity( const xAOD::IParticle * const p1, const xAOD::IParticle * const p2 )
    {
      return xAOD::P4Helpers::deltaRapidity(*p1, *p2);
    }


    inline
    double deltaEta( const xAOD::IParticle& p1, const xAOD::IParticle& p2 )
    {
      return p1.eta() - p2.eta();
    }

    inline
    double deltaEta( const xAOD::IParticle * const p1, const xAOD::IParticle * const p2 )
    {
      return xAOD::P4Helpers::deltaEta(*p1, *p2);
    }


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

    inline
    double deltaPhi( const xAOD::IParticle& p4, const double phi )
    {
      return xAOD::P4Helpers::deltaPhi( p4.phi(), phi );
    }

    inline
    double deltaPhi( const xAOD::IParticle & pA, const xAOD::IParticle & pB )
    {
      return xAOD::P4Helpers::deltaPhi( pA.phi(), pB.phi() );
    }

    inline
    double deltaPhi( const xAOD::IParticle * const pA, const xAOD::IParticle * const pB )
    { return xAOD::P4Helpers::deltaPhi( pA->phi(), pB->phi() ); }



    inline
    double deltaPhi( const xAOD::IParticle & pA, const xAOD::MissingET & met )
    {
      return xAOD::P4Helpers::deltaPhi( pA.phi(), met.phi() );
    }

    inline
    double deltaPhi( const xAOD::IParticle * const pA, const xAOD::MissingET * const met )
    { return xAOD::P4Helpers::deltaPhi( pA->phi(), met->phi() ); }



    inline
    double deltaR2( const xAOD::IParticle& p4, double rapidity, double phi, bool useRapidity=true )
    {
      const double dPhi = xAOD::P4Helpers::deltaPhi( p4, phi );
      if (useRapidity) {
        const double dRapidity = p4.rapidity() - rapidity;
        return dRapidity*dRapidity + dPhi*dPhi;
      }
      else {
        const double dEta = p4.eta() - rapidity;
        return dEta*dEta + dPhi*dPhi;
      }
    }

    inline
    double deltaR2( const xAOD::IParticle& pA, const xAOD::IParticle& pB, bool useRapidity=true )
    {
      const double dPhi = xAOD::P4Helpers::deltaPhi( pA, pB );
      const double dPhiSq = dPhi*dPhi;
      if (useRapidity) {
        const double dRapidity = xAOD::P4Helpers::deltaRapidity( pA, pB );
        return dRapidity*dRapidity + dPhiSq;
      }
      else {
        const double dEta = xAOD::P4Helpers::deltaEta( pA, pB );
        return dEta*dEta + dPhiSq;
      }
    }

    inline
    double deltaR2( const xAOD::IParticle * const pA, const xAOD::IParticle * const pB, bool useRapidity=true )
    { return xAOD::P4Helpers::deltaR2( *pA, *pB, useRapidity ); }



    inline
    double deltaR( const xAOD::IParticle& p4, double rapidity, double phi, bool useRapidity=true )
    { return std::sqrt( xAOD::P4Helpers::deltaR2( p4, rapidity, phi, useRapidity ) ); }

    inline
    double deltaR( const xAOD::IParticle& pA, const xAOD::IParticle& pB, bool useRapidity=true )
    { return std::sqrt( xAOD::P4Helpers::deltaR2( pA, pB, useRapidity ) ); }

    inline
    double deltaR( const xAOD::IParticle * const pA, const xAOD::IParticle * const pB, bool useRapidity=true )
    { return std::sqrt( xAOD::P4Helpers::deltaR2( *pA, *pB, useRapidity ) ); }



    inline
    bool isInDeltaR( const xAOD::IParticle& p1, const xAOD::IParticle& p2,
                     double dR, bool useRapidity=true )
    {
      const double dPhi = std::abs( xAOD::P4Helpers::deltaPhi(p1,p2) ); // in [-pi,pi)
      if ( CxxUtils::fpcompare::greater(dPhi,dR) ) return false;        // <==
      if (useRapidity) {
        const double dRapidity = std::abs( xAOD::P4Helpers::deltaRapidity(p1,p2) );
        if ( CxxUtils::fpcompare::greater(dRapidity,dR) ) return false;        // <==
        const double deltaR2 = dRapidity*dRapidity + dPhi*dPhi;
        if ( CxxUtils::fpcompare::greater(deltaR2,dR*dR) ) return false;  // <==
        return true;
      }
      else {
        const double dEta = std::abs( xAOD::P4Helpers::deltaEta(p1,p2) );
        if ( CxxUtils::fpcompare::greater(dEta,dR) ) return false;        // <==
        const double deltaR2 = dEta*dEta + dPhi*dPhi;
        if ( CxxUtils::fpcompare::greater(deltaR2,dR*dR) ) return false;  // <==
        return true;
      }
    }



    inline
    double deltaAbsP( const xAOD::IParticle& pA, const xAOD::IParticle& pB )
    {
      const double absPA = std::abs( pA.p4().P() );
      const double absPB = std::abs( pB.p4().P() );
      return absPA - absPB;
    }

    inline
    double deltaAbsP( const xAOD::IParticle * const pA, const xAOD::IParticle * const pB )
    { return xAOD::P4Helpers::deltaAbsP( *pA, *pB ); }


  } //> namespace P4Helpers

} // End: namespace xAOD


#endif // FOURMOMUTILS_XAODP4HELPERS_H

---