KinematicSelectorCore.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// Dear emacs, this is -*-c++-*-
#ifndef ANALYSISUTILS_KINEMATICSELECTORCORE_H 
#define ANALYSISUTILS_KINEMATICSELECTORCORE_H 
 
// STL includes
#include <string>
#include <cfloat>
 
// Atlas includes
#include "AraTool/AraToolBase.h"
#include "AnalysisUtils/ISelectorCore.h"
#include "EventKernel/IParticle.h"
#include "EventKernel/INavigable4Momentum.h"
 
static const InterfaceID IID_KinematicSelectorCore("KinematicSelectorCore", 1, 0);
 
 
class KinematicSelectorCore : public ISelectorCore, virtual public AraToolBase
{
public:
  KinematicSelectorCore(PropertyMgr *pmgr=0);
  
  virtual ~KinematicSelectorCore() {}
 
public:
  static const InterfaceID& interfaceID() { return IID_KinematicSelectorCore; };
 
public:
  virtual StatusCode initialize();
 
  virtual StatusCode finalize();
 
 
 
public:
  bool accept( const IParticle* part ) const;
 
 
  bool accept( const INavigable4Momentum* part ) const;
 
 
public:  
 
  inline bool passPt( const INavigable4Momentum* part ) const
  {
    double pt = part->pt();
    if ( (std::isinf(pt) || std::isnan(pt)) ) return true;
    return ( pt > m_minPt  &&  pt < m_maxPt );
  };
 
 
  inline bool passP( const INavigable4Momentum* part ) const
  {
    double p = part->p();
    if ( (std::isinf(p) || std::isnan(p)) ) return true;
    return ( p > m_minP  &&  p < m_maxP );
  };
 
 
  inline bool passEt( const INavigable4Momentum* part ) const
  {
    double et = part->et();
    if ( (std::isinf(et) || std::isnan(et)) ) return true;
    return ( et > m_minEt  &&  et < m_maxEt );
  };
 
 
  inline bool passE( const INavigable4Momentum* part ) const
  {
    double e = part->e();
    if ( (std::isinf(e) || std::isnan(e)) ) return true;
    return ( e > m_minE  &&  e < m_maxE );
  };
 
 
  inline bool passEta( const INavigable4Momentum* part ) const
  {
    double eta = part->eta();
    if ( (std::isinf(eta) || std::isnan(eta)) ) return true;
    return ( eta > m_minEta  &&  eta < m_maxEta );
  };
 
 
  inline bool passAbsEta( const INavigable4Momentum* part ) const
  {
    double eta = part->eta();
    if ( (std::isinf(eta) || std::isnan(eta)) ) return true;
    return ( fabs(eta) > m_minAbsEta  &&  fabs(eta) < m_maxAbsEta );
  };
 
 
  bool passEtaVetoRanges( const INavigable4Momentum* part ) const;
 
 
  inline bool passPhi( const INavigable4Momentum* part ) const
  {
    double phi = part->phi();
    if ( (std::isinf(phi) || std::isnan(phi)) ) return true;
    return ( phi > m_minPhi  &&  phi < m_maxPhi );
  };
 
 
  bool passPhiVetoRanges( const INavigable4Momentum* part ) const;
 
 
  inline bool passMass( const INavigable4Momentum* part ) const
  {
    double mass = part->m();
    if ( (std::isinf(mass) || std::isnan(mass)) ) return true;
    return ( mass > m_minMass  &&  mass < m_maxMass );
  };
 
 
 
public:
  void setminPt(double val) { m_minPt=val; }
 
  double getminPt(void) { return m_minPt; }
 
  void setmaxPt(double val) { m_maxPt=val; }
 
  double getmaxPt(void) { return m_maxPt; }
  
 
  void setminP(double val) { m_minP=val; }
 
  double getminP(void) { return m_minP; }
 
  void setmaxP(double val) { m_maxP=val; }
 
  double getmaxP(void) { return m_maxP; }
  
 
  void setminEt(double val) { m_minEt=val; }
 
  double getminEt(void) { return m_minEt; }
 
  void setmaxEt(double val) { m_maxEt=val; }
 
  double getmaxEt(void) { return m_maxEt; }
  
 
  void setminE(double val) { m_minE=val; }
 
  double getminE(void) { return m_minE; }
 
  void setmaxE(double val) { m_maxE=val; }
 
  double getmaxE(void) { return m_maxE; }
  
 
  void setminEta(double val) { m_minEta=val; }
 
  double getminEta(void) { return m_minEta; }
 
  void setmaxEta(double val) { m_maxEta=val; }
 
  double getmaxEta(void) { return m_maxEta; }
  
 
  void setminAbsEta(double val) { m_minAbsEta=val; }
 
  double getminAbsEta(void) { return m_minAbsEta; }
 
  void setmaxAbsEta(double val) { m_maxAbsEta=val; }
 
  double getmaxAbsEta(void) { return m_maxAbsEta; }
 
 
  void setEtaVetoRanges(std::string &range) ;
 
  std::string getEtaVetoRanges(void) { return m_etaVetoRanges; }
  
 
  void setminPhi(double val) { m_minPhi=val; }
 
  double getminPhi(void) { return m_minPhi; }
 
  void setmaxPhi(double val) { m_maxPhi=val; }
 
  double getmaxPhi(void) { return m_maxPhi; }
  
 
  void setPhiVetoRanges(std::string &range) ;
 
  std::string getPhiVetoRanges(void) { return m_phiVetoRanges; }
  
 
  void setminMass(double val) { m_minMass=val; }
 
  double getminMass(void) { return m_minMass; }
 
  void setmaxMass(double val) { m_maxMass=val; }
 
  double getmaxMass(void) { return m_maxMass; }
 
 
  // Private member functions
private:
  void convertStringRange( std::string &range,
                           std::vector<double> &minVals, 
                           std::vector<double> &maxVals );
 
 
  // Private class variables  
private:
  double m_minPt;
 
  double m_maxPt;
  
 
  double m_minP;
 
  double m_maxP;
  
 
  double m_minE;
 
  double m_maxE;
 
 
  double m_minEt;
 
  double m_maxEt;
 
 
  double m_minEta;
 
  double m_maxEta;
 
 
  double m_minAbsEta;
 
  double m_maxAbsEta;
 
 
  std::string m_etaVetoRanges;
 
  std::vector<double> m_minEtaVeto;
 
  std::vector<double> m_maxEtaVeto;
 
 
  double m_minPhi;
 
  double m_maxPhi;
 
 
  std::string m_phiVetoRanges;
 
  std::vector<double> m_minPhiVeto;
 
  std::vector<double> m_maxPhiVeto;
 
 
  double m_minMass;
 
  double m_maxMass;
 
};
 
#endif // ANALYSISUTILS_KINEMATICSELECTORCORE_H