xAODP4Helpers.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// 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( double rapidity1, double phi1, double rapidity2, double phi2 )
    {
      const double dPhi = xAOD::P4Helpers::deltaPhi( phi1, phi2 );
      const double dRapidity = rapidity1-rapidity2;
      return dRapidity*dRapidity + dPhi*dPhi;
    }

    inline
    double deltaR2( const xAOD::IParticle& p4, double rapidity, double phi, bool useRapidity=true )
    {
      if (useRapidity) {
        return xAOD::P4Helpers::deltaR2(p4.rapidity(),p4.phi(),rapidity,phi);
      }
      else {
        return xAOD::P4Helpers::deltaR2(p4.eta(),p4.phi(),rapidity,phi);
      }
    }

    inline
    double deltaR2( const xAOD::IParticle& pA, const xAOD::IParticle& pB, bool useRapidity=true )
    {
      if (useRapidity) {
        return xAOD::P4Helpers::deltaR2(pA.rapidity(),pA.phi(),pB.rapidity(),pB.phi());
      }
      else {
        return xAOD::P4Helpers::deltaR2(pA.eta(),pA.phi(),pB.eta(),pB.phi());
      }
    }

    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( double rapidity1, double phi1, double rapidity2, double phi2 )
    { return std::sqrt( xAOD::P4Helpers::deltaR2( rapidity1, phi1, rapidity2, phi2 ) ); }

    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