---

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_kinehelper__
#define __Atlfast_kinehelper__

#include "AtlfastCode/IKinematic.h"
#include "AtlfastCode/Cluster.h"
#include "AtlfastCode/Phi.h"

namespace Atlfast {
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 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

---