KinematicHelper.h

Go to the documentation of this file.

//=============================================
// Helper class
//=============================================
//
// This class is a holding place for a set of useful manipulations
// on quantities honourinf the
//           IKinematic interface
//
// In a sense this is not very OO in that it is all based upon the user
// having collections of IKinematics, and then wanting to sum them, take an
// invariant mass...etc. Perhaps there is a more OO view of this sort
// of operation which needs to be developed. 
//
// Nevertheless at present the functionality is implemented here in one place.
//
// Most methods are overloaded to allow for references or pointers as arguments 
   
#ifndef ATLFAST_KINEMATICHELPER_H
#define ATLFAST_KINEMATICHELPER_H

#ifndef CLHEP_LORENTZVECTOR_H
#define CLHEP_LORENTZVECTOR_H
#include "CLHEP/Vector/LorentzVector.h"
#endif

namespace Atlfast {
  class IKinematic;
class KinematicHelper { 

  public:

  // ---------------------------------------------------------
  // Return the distance in eta-phi space between two items
  //  template< class Item1, class Item2 >
  //    double deltaR( Item1* , Item2*  ) ;
  double deltaR( IKinematic& a, IKinematic& b ) ;
  double deltaR( IKinematic* a, IKinematic* b ) ;


  // ---------------------------------------------------------
  double deltaPhi( IKinematic& a, IKinematic& b ) ;
  double deltaPhi( IKinematic* a, IKinematic* b ) ;


  // ---------------------------------------------------------
  double mass( IKinematic& a, IKinematic& b ) ;
  double mass( IKinematic* a, IKinematic* b ) ;

    template< class Iter > 
    double mass( Iter begin, Iter end )
    {
      HepLorentzVector temp(0.,0.,0.,0.) ;
      for( Iter i = begin; i < end; ++i )
        {
          temp += (*i)->momentum() ;
        }
      return temp.m() ;
    }


  // --------------------------------------------------
  template< class Iter> //, class Reference >
    double sumETInCone( Iter begin, 
                        Iter end, 
                        IKinematic* reference,
                        double rCone 
                        )
{  
  double result = 0.0;     
  for( Iter itr = begin; itr < end; ++itr )
    {       
      if( this->deltaR( reference, *itr ) < rCone ) 
        { 
          result += (*itr)->eT() ; 
        }
    }  
  return result ;
}

// --------------------------------------------------
  template< class Iter> //, class Reference >
    double sumETInHalo( Iter begin,
                        Iter end,
                        IKinematic* reference,
                        double rLower,
                        double rHigher
                        )
    {
      double result = 0.0;
      for( Iter itr = begin; itr < end; ++itr )
        {
          if( this->deltaR( reference, *itr ) > rLower 
              && this->deltaR( reference, *itr ) < rHigher
              )
            {
              result += (*itr)->eT() ;
            }
        }
      return result ;
    }  
  
  // --------------------------------------------------
  template< class Iter> //, class Reference >
    HepLorentzVector sumMomentumInHalo( Iter begin,
                                        Iter end,
                                        IKinematic* reference,
                                        double rLower,
                                        double rHigher
                                        )
    {
      HepLorentzVector result(0.,0.,0.,0.);
      for( Iter itr = begin; itr < end; ++itr )
        {
          if( this->deltaR( reference, *itr ) > rLower
              && this->deltaR( reference, *itr ) < rHigher
              )
            {
              result += (*itr)->momentum() ;
            }
        }
      return result ;
    }
  

  //  template< class Iterator> //, class Reference >
  //    double sumETInCone( Iterator begin, 
  //                    Iterator end, 
  //            IKinematic& reference,
  //            double rCone 
  //          ) ;


 private:
  
  // To convert the iterated and reference Types into a standard form
  //IKinematic* regulateType( IKinematic& x ) { return &x ; }
  //IKinematic* regulateType( IKinematic* x ) { return x ; }


};

} // namespace end

#endif

---