FunctionObjects.h

Go to the documentation of this file.

//================================================
//
// A set of "function objects"  for use with some 
// STL generic algorithms.
//
// ===============================================
//
//  The function objects implemented here allow STL generic algortihms
//  to be used on iterable collections containing any objects which
//  honour the 
//           IKinematic interface
//
//  I.e. if your object inherits as:
//       class YourObject : virtual public IKinematic
//  then these will work for you.
//
//  The collections may contain the objects themselves, or pointers to
//  the objects
// 
//  Currently included:
//  
//  Function objects for sort  (in namespace SortAttribute )
//
//      AscendingPhi       DescendingPhi       simple sort by phi
//      AscendingEta       DescendingEta       simple sort by eta
//      AscendingET        DescendingET        simple sort by trans. energy
//      AscendingPT        DescendingPT        simple sort by trans. momentum
//      AscendingMT        DescendingMT        simple sort by trans. mass
//      
//      DeltaPhi    sort by increasing distance in phi from a reference
//      DeltaEta    sort by increasing distance in eta from a reference
//      DeltaR      sort by increasing distance in eta-phi from a reference
//      (note the reference is set in the constructor)
//

#ifndef ATLFAST_FUNCTIONOBJECTS_H
#define ATLFAST_FUNCTIONOBJECTS_H

#include "AtlfastEvent/IKinematic.h"
#include "AtlfastEvent/Phi.h"

#include <cmath>


//--------------------------------------------------------
//
// Function objects for sort
//

namespace SortAttribute {
  using std::abs;
  
  //............ phi ...........


  class AscendingPhi {
  public:
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const { 
      return( a->phi() < b->phi() ) ; }
    
     bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
       { return this->operator() ( &a, &b ) ; }
  };
  class DescendingPhi {
  public:
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const
      { return( a->phi() > b->phi() ) ; }
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return( a.phi() > b.phi() ) ; }
  };

  
  //........... eta ..............
  class AscendingEta {
  public:
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const
      { return( a->eta() < b->eta() ) ; }
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return( a.eta() < b.eta() ) ; }
  };
  class DescendingEta {
  public:
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const
      { return( a->eta() > b->eta() ) ; }
    bool operator() 
     ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return( a.eta() > b.eta() ) ; }
  };


//........... eT ..............

  class AscendingET {
  public:
    
    // For sorting
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const
      { return( a->eT() < b->eT() ) ; }
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return( a.eT() < b.eT() ) ; }

   // For applying cuts - not documented yet
    bool operator() 
      ( const double boundary , const Atlfast::IKinematic* a ) const
      { return (boundary  < a->eT()) ; }
    bool operator() 
      ( const double boundary , const Atlfast::IKinematic& a ) const
      { return (boundary  < a.eT()) ; }

  };
  class DescendingET {
  public:
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const
      { return( a->eT() > b->eT() ) ; }
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return( a.eT() > b.eT() ) ; }
  };


  //........... pT ..............
  class AscendingPT {
  public:
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const
      { return( a->pT() < b->pT() ) ; }
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return( a.pT() < b.pT() ) ; }
  };
  class DescendingPT {
  public:
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const
      { return( a->pT() > b->pT() ) ; }
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return( a.pT() > b.pT() ) ; }
  };


  //........... mT ..............
  class AscendingMT {
  public:
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const
      { return( a->mT() < b->mT() ) ; }
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return( a.mT() < b.mT() ) ; }
  };
  class DescendingMT {
  public:
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const
      { return( a->mT() > b->mT() ) ; }
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return( a.mT() > b.mT() ) ; }
  };
  
  //........... Delta phi ..............
  class DeltaPhi {
    
  private:
    Atlfast::IKinematic* ref ;

  public:
    
    // Constructors which accept the reference 
    DeltaPhi( Atlfast::IKinematic* reference ) : ref(reference) {} 
    DeltaPhi( Atlfast::IKinematic& reference ) : ref(&reference) {} 
    
    //function operator
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const
      { 
      Phi a_dPhi( a->phi() - ref->phi() ) ;
      Phi b_dPhi( b->phi() - ref->phi() ) ;
      
      return  ( abs(a_dPhi) < abs(b_dPhi) ) ;
   }
    
    //forwarding
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return this->operator() ( &a, &b ) ; }

  };

  //........... Delta eta ..............
  class DeltaEta {
    
  private:
    Atlfast::IKinematic* ref ;
    
  public:
    
    DeltaEta( Atlfast::IKinematic* reference ) : ref(reference) {} 
    DeltaEta( Atlfast::IKinematic& reference ) : ref(&reference) {} 
    
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const { 
      return( 
             abs(a->eta() - ref->eta()) 
             < 
             abs(b->eta() - ref->eta()) 
             );
    }
    
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return this->operator() ( &a, &b ) ; }

  };

  
  //........... Delta R  (eta-phi) ..............
  class DeltaR {
    
  private:
    Atlfast::IKinematic* ref ;
    
  public:
    
    DeltaR( Atlfast::IKinematic* reference ) : ref(reference) {}
    DeltaR( Atlfast::IKinematic& reference ) : ref(&reference) {} 
    
    bool operator() 
      ( const Atlfast::IKinematic* a, const Atlfast::IKinematic* b  ) const { 
      
      Phi a_dPhi( a->phi() - ref->phi() ) ;
      Phi b_dPhi( b->phi() - ref->phi() ) ;
      
      double dista = 
        sqrt(
             (a_dPhi*a_dPhi) +
             (a->eta() - ref->eta())*(a->eta() - ref->eta()) 
             );
      
      double distb = 
        sqrt(
             (b_dPhi*b_dPhi) +
             (b->eta() - ref->eta())*(b->eta() - ref->eta()) 
             );
      
      return ( dista < distb ) ;
    }

    
    bool operator() 
      ( const Atlfast::IKinematic& a, const Atlfast::IKinematic& b  ) const
      { return this->operator() ( &a, &b ) ; }

  };

  
  
} // End of SortCondition  namespace


//**********************************************
// For use with partition()
//**********************************************


namespace PartitionCondition {
  
  
  //........... eT ..............
  class AboveThresholdET {
    
  public:

    AboveThresholdET( double boundary ) : m_boundary(boundary) {}
    bool operator() ( const Atlfast::IKinematic* a ) const
      { return (m_boundary  < a->eT()) ; }
    bool operator() ( const Atlfast::IKinematic& a ) const
      { return (m_boundary  < a.eT()) ; }
    
  private:
    double m_boundary ;
    
  };
  class BelowThresholdET {
    
  public:
    
    BelowThresholdET( double boundary ) : m_boundary(boundary) {}
    bool operator() ( const Atlfast::IKinematic* a ) const
      { return (m_boundary  > a->eT()) ; }
    bool operator() ( const Atlfast::IKinematic& a ) const
    { return (m_boundary  > a.eT()) ; }
    
  private:
    double m_boundary ;
    
  };
  
//................. DeltaR .....................
  
  class BelowThresholdDeltaR {
    
  public:
    BelowThresholdDeltaR( const Atlfast::IKinematic* ref, double barreldRLimit,
                          double forwarddRLimit = 0, double etaBoundary = 0) :
      m_barreldRLimit(barreldRLimit), m_forwarddRLimit(forwarddRLimit), 
      m_etaBoundary(etaBoundary), m_ref(ref) {}
    
    BelowThresholdDeltaR( const Atlfast::IKinematic& ref, double barreldRLimit,
                          double forwarddRLimit = 0, double etaBoundary = 0) :
      m_barreldRLimit(barreldRLimit), m_forwarddRLimit(forwarddRLimit), 
      m_etaBoundary(etaBoundary), m_ref(&ref) {}
    
    bool operator() ( const Atlfast::IKinematic* a ) const { 
      Phi dphi( a->phi() - m_ref->phi() ) ;
      
      double dist = 
        sqrt(
             (dphi*dphi) +
             (a->eta() - m_ref->eta())*(a->eta() - m_ref->eta()) 
             );
      
      if (!m_forwarddRLimit){
        // Use universal dR cut limit
        return (dist < m_barreldRLimit);
      }else{
        // Use eta-dependent dR cut limit
        return ( (a->eta()*a->eta() <= m_etaBoundary*m_etaBoundary &&
                  dist < m_barreldRLimit) ||
                 ( a->eta()*a->eta() > m_etaBoundary*m_etaBoundary &&
                   dist < m_forwarddRLimit ) );
      }
    }
    
    bool operator() 
      ( const Atlfast::IKinematic& a ) const 
      { return this->operator()( &a ) ; }
    
  private:
    double m_barreldRLimit;
    double m_forwarddRLimit;
    double m_etaBoundary;
    const Atlfast::IKinematic* m_ref ;
    
  };
  
}  // End PartitionCondition namespace




#endif

---