---

CellHelper.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 
//           ICellWrapper interface
//
//  I.e. if your object inherits as:
//       class YourObject : virtual public ICellWrapper
//  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
//      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__
#define ___Atlfast_functionobjects__

#include "AtlfastCode/IKinematic.h"
#include <cmath>
#include <cstdlib>
#include "AtlfastCode/Phi.h"


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

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

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


//........... eT ..............
  //........... pT ..............
  class AscendingPT {
  public:
    bool operator() 
      ( const Atlfast::ICellWrapper* a, const Atlfast::ICellWrapper* b  ) const
      { return( a->pT() < b->pT() ) ; }
    bool operator() 
      ( const Atlfast::ICellWrapper& a, const Atlfast::ICellWrapper& b  ) const
      { return( a.pT() < b.pT() ) ; }
  };
  class DescendingPT {
  public:
    bool operator() 
      ( const Atlfast::ICellWrapper* a, const Atlfast::ICellWrapper* b  ) const
      { return( a->pT() > b->pT() ) ; }
    bool operator() 
      ( const Atlfast::ICellWrapper& a, const Atlfast::ICellWrapper& b  ) const
      { return( a.pT() > b.pT() ) ; }
  };
  //........... Delta phi ..............
  class DeltaPhi {
    
  private:
    Atlfast::ICellWrapper* ref ;

  public:
    
    // Constructors which accept the reference 
    DeltaPhi( Atlfast::ICellWrapper* reference ) : ref(reference) {} 
    DeltaPhi( Atlfast::ICellWrapper& reference ) : ref(&reference) {} 
    
    //function operator
    bool operator() 
      ( const Atlfast::ICellWrapper* a, const Atlfast::ICellWrapper* 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::ICellWrapper& a, const Atlfast::ICellWrapper& b  ) const
      { return this->operator() ( &a, &b ) ; }

  };

  //........... Delta eta ..............
  class DeltaEta {
    
  private:
    Atlfast::ICellWrapper* ref ;
    
  public:
    
    // Constructors which accept the reference 
    DeltaEta( Atlfast::ICellWrapper* reference ) : ref(reference) {} 
    DeltaEta( Atlfast::ICellWrapper& reference ) : ref(&reference) {} 
    
    //function operator
    bool operator() 
      ( const Atlfast::ICellWrapper* a, const Atlfast::ICellWrapper* b  ) const { 
      return( 
             abs(a->eta() - ref->eta()) 
             < 
             abs(b->eta() - ref->eta()) 
             );
    }
    
    //forwarding
    bool operator() 
      ( const Atlfast::ICellWrapper& a, const Atlfast::ICellWrapper& b  ) const
      { return this->operator() ( &a, &b ) ; }

  };

  
  //........... Delta R  (eta-phi) ..............
  class DeltaR {
    
  private:
    Atlfast::ICellWrapper* ref ;
    
  public:
    
    // Constructors which accept the reference 
    DeltaR( Atlfast::ICellWrapper* reference ) : ref(reference) {} 
    DeltaR( Atlfast::ICellWrapper& reference ) : ref(&reference) {} 
    
    //function operator for comparing two objects
    bool operator() 
      ( const Atlfast::ICellWrapper* a, const Atlfast::ICellWrapper* 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 ) ;
    }

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

  };

  
  
} // End of SortCondition  namespace


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


namespace CellPartitionCondition {
  
  
  //........... pT ..............
  
  class AboveThresholdPT {
    
  public:

    AboveThresholdPT( double boundary ) : m_boundary(boundary) {}
    
    bool operator() ( const Atlfast::ICellWrapper* a ) const
      { return (m_boundary  < a->pT()) ; }
    bool operator() ( const Atlfast::ICellWrapper& a ) const
      { return (m_boundary  < a.pT()) ; }
    
  private:
    double m_boundary ;
    
  };
  class BelowThresholdpT {
    
  public:
    
    BelowThresholdpT( double boundary ) : m_boundary(boundary) {}
    
    bool operator() ( const Atlfast::ICellWrapper* a ) const
      { return (m_boundary  > a->pT()) ; }
    bool operator() ( const Atlfast::ICellWrapper& a ) const
    { return (m_boundary  > a.pT()) ; }
    
  private:
    double m_boundary ;
    
  };
  
//................. DeltaR .....................
  
  class BelowThresholdDeltaR {
    
  public:
    BelowThresholdDeltaR( Atlfast::ICellWrapper* ref, double boundary ) 
      : m_boundary(boundary), m_ref(ref) {}
    BelowThresholdDeltaR( Atlfast::ICellWrapper& ref, double boundary ) 
      : m_boundary(boundary), m_ref(&ref) {}
    bool operator() ( const Atlfast::ICellWrapper* a ) const
      { 
        Phi dphi( a->phi() - m_ref->phi() ) ;
        
        double dist = 
          sqrt(
               (dphi*dphi) +
               (a->eta() - m_ref->eta())*(a->eta() - m_ref->eta()) 
               );
        
        return (dist < m_boundary) ;
        
      }
    
    bool operator() 
      ( const Atlfast::ICellWrapper& a ) const 
      { return this->operator()( &a ) ; }
    
  private:
    double m_boundary ;
    Atlfast::ICellWrapper* m_ref ;
    
  };
  
//................. DeltaPT .....................
  
  class BelowThresholdDeltaPT {
    
  public:
    BelowThresholdDeltaPT( Atlfast::ICellWrapper* ref, double boundary ) 
      : m_boundary(boundary), m_ref(ref) {}
    
    BelowThresholdDeltaPT( Atlfast::ICellWrapper& ref, double boundary ) 
      : m_boundary(boundary), m_ref(&ref) {}
    bool operator() ( const Atlfast::ICellWrapper* a ) const
      { 
        return ( abs( a->pT() - m_ref->pT() ) < m_boundary)  ;
      }
    bool operator() 
      ( const Atlfast::ICellWrapper& a ) const 
      { return this->operator()( &a ) ; }
    bool operator() 
      ( const Atlfast::ICellWrapper** a ) const 
      { return this->operator()( *a ) ; }
    
  private:
    double m_boundary ;
    Atlfast::ICellWrapper* m_ref ;
    
  };
  
//................. DeltaPT .....................
  
  class CellValidation {
    
  public:
    CellValidation( Atlfast::ICellWrapper* ref, 
                    double maxEtaDiff,
                    double maxPhiDiff,
                    double maxPtDiff ) : 
      m_ref(ref), 
      m_maxEtaDiff(maxEtaDiff), 
      m_maxPhiDiff(maxPhiDiff), 
      m_maxPtDiff(maxPtDiff) {}
    
    CellValidation( Atlfast::ICellWrapper& ref,
                    double maxEtaDiff,
                    double maxPhiDiff,
                    double maxPtDiff ) : 
      m_ref(&ref), 
      m_maxEtaDiff(maxEtaDiff), 
      m_maxPhiDiff(maxPhiDiff), 
      m_maxPtDiff(maxPtDiff) {}
    bool operator() ( const Atlfast::ICellWrapper* a ) const
      { 
        double delphi = abs( (Phi(a->phi()) - Phi(m_ref->phi())) );
        double deleta = abs( ( a->eta() - m_ref->eta()) );
        double delpt  = abs( a->pT() - m_ref->pT() );
        
        return ( 
                delphi< m_maxPhiDiff &&
                deleta< m_maxEtaDiff &&
                delpt < m_maxPtDiff
                );
      }
    bool operator() 
      ( const Atlfast::ICellWrapper& a ) const 
      { return this->operator()( &a ) ; }
    bool operator() 
      ( const Atlfast::ICellWrapper** a ) const 
      { return this->operator()( *a ) ; }
    
  private:
    Atlfast::ICellWrapper* m_ref ;
    double m_maxEtaDiff;
    double m_maxPhiDiff;
    double m_maxPtDiff;    
  };
  
  class MatchParticle {
    
  public:
    MatchParticle( Atlfast::ICellWrapper* ref, 
                    double maxEtaDiff,
                    double maxPhiDiff,
                    double maxPtDiff ) : 
      m_ref(ref), 
      m_maxEtaDiff(maxEtaDiff), 
      m_maxPhiDiff(maxPhiDiff), 
      m_maxPtDiff(maxPtDiff) {}

    MatchParticle( Atlfast::ICellWrapper& ref,
                    double maxEtaDiff,
                    double maxPhiDiff,
                    double maxPtDiff ) : 
      m_ref(&ref), 
      m_maxEtaDiff(maxEtaDiff), 
      m_maxPhiDiff(maxPhiDiff), 
      m_maxPtDiff(maxPtDiff) {}
    bool operator() ( const Atlfast::ICellWrapper* a ) const
      { 
        std::vector<const HepMC::GenParticle*> p=a->particles();
        std::vector<const HepMC::GenParticle*>::const_iterator ip=p.begin();
        for(;ip!=p.end();++ip){
          
          double delphi = abs( Phi((*ip)->momentum().phi()) - Phi( m_ref->phi() ) );
          double deleta = abs( (*ip)->momentum().pseudoRapidity() - m_ref->eta() );
          double delpt  = abs( (*ip)->momentum().perp() - m_ref->pT() );
          if( 
             delphi< m_maxPhiDiff &&
             deleta< m_maxEtaDiff &&
             delpt < m_maxPtDiff
             ) return true;
        }
        return false;
      }
    bool operator() 
      ( const Atlfast::ICellWrapper& a ) const 
      { return this->operator()( &a ) ; }
    bool operator() 
      ( const Atlfast::ICellWrapper** a ) const 
      { return this->operator()( *a ) ; }
    
  private:
    Atlfast::ICellWrapper* m_ref ;
    double m_maxEtaDiff;
    double m_maxPhiDiff;
    double m_maxPtDiff;    
  };

  class AddModPt{
  public:
    double operator()( double a, 
                       Atlfast::ICellWrapper* b){
      double result = (a + abs( b->pT() ) );
      return result;
    }
    
  };
}  // End PartitionCondition namespace




#endif

---