MomentumFilter.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// MomentumFilter.h 
// Header file for class MomentumFilter
// Author: S.Binet<binet@cern.ch>
#ifndef ANALYSISUTILS_MOMENTUMFILTER_H 
#define ANALYSISUTILS_MOMENTUMFILTER_H 
 
#include <typeinfo>
 
#include "AthenaKernel/getMessageSvc.h"
#include "GaudiKernel/MsgStream.h"
 
#include "AnalysisUtils/IFilter.h"
#include "AnalysisUtils/FilterRange.h"
#include "AnalysisUtils/PhiFilterRange.h"
 
template <typename T>
class MomentumFilter : virtual public IFilter<T>
{ 
 
  // Public methods: 
 public: 
 
  MomentumFilter();
 
  MomentumFilter( const MomentumFilter<T>& filter );
 
  // Constructor with parameters: 
 
  virtual ~MomentumFilter(); 
 
  MomentumFilter<T>& operator=(const MomentumFilter<T>& rhs); 
 
  // Const methods: 
 
  virtual bool isAccepted( const T * element ) const;
 
  double pxMin() const;
 
  double pxMax() const;
 
  double pyMin() const;
 
  double pyMax() const;
 
  double pzMin() const;
 
  double pzMax() const;
 
  double eneMin() const;
 
  double eneMax() const;
 
  double etaMin() const;
 
  double etaMax() const;
 
  double phiMin() const;
 
  double phiMax() const;
 
  double massMin() const;
 
  double massMax() const;
 
  double ptMin() const;
 
  double ptMax() const;
 
  double atlasPhi( const double phi ) const;
  
  // Non-const methods: 
 
  void setFilter( const IFilterCuts * filter );
 
  void setPxMin( const double pxMin );
 
  void setPxMax( const double pxMax );
 
  void setPyMin( const double pyMin );
 
  void setPyMax( const double pyMax );
 
  void setPzMin( const double pzMin );
 
  void setPzMax( const double pzMax );
 
  void setEneMin( const double eneMin );
 
  void setEneMax( const double eneMax );
 
  void setEtaMin( const double etaMin );
 
  void setEtaMax( const double etaMax );
 
  void setPhiMin( const double phiMin );
 
  void setPhiMax( const double phiMax );
 
  void setMassMin( const double massMin );
 
  void setMassMax( const double massMax );
 
  void setPtMin( const double ptMin );
 
  void setPtMax( const double ptMax );
 
  void setRange( const std::string& name,
         const double min, const double max );
 
  // Protected method: 
 protected: 
  
  // Protected data: 
 protected: 
  
  FilterRange m_pxRange;
  
  FilterRange m_pyRange;
  
  FilterRange m_pzRange;
  
  FilterRange m_eneRange;
  
  FilterRange m_etaRange;
  
  PhiFilterRange m_phiRange;
  
  FilterRange m_massRange;
  
  FilterRange m_ptRange;
 
  private :
 
}; 
 
// I/O operators
//MsgStream& operator<<( MsgStream & msg, const MomentumFilter &obj );
 
// Inline methods: 
 
template<typename T>
inline MomentumFilter<T>::MomentumFilter() :
  IFilterCuts(),
  IFilter<T>(),
  m_pxRange(),
  m_pyRange(),
  m_pzRange(),
  m_eneRange(),
  m_etaRange(),
  m_phiRange(),
  m_massRange(),
  m_ptRange()
{}
 
template<typename T>
inline MomentumFilter<T>::MomentumFilter( const MomentumFilter<T>& rhs ) :
  IFilterCuts(rhs),
  IFilter<T>( rhs ),
  m_pxRange( rhs.m_pxRange ),
  m_pyRange( rhs.m_pyRange ),
  m_pzRange( rhs.m_pzRange ),
  m_eneRange(rhs.m_eneRange ),
  m_etaRange(rhs.m_etaRange ),
  m_phiRange(rhs.m_phiRange ),
  m_massRange(rhs.m_massRange ),
  m_ptRange( rhs.m_ptRange )
{}
 
template<typename T>
MomentumFilter<T>::~MomentumFilter() {}
 
template<typename T>
inline
MomentumFilter<T>& MomentumFilter<T>::operator=(const MomentumFilter<T>& rhs)
{
  if ( this != &rhs ) {
    IFilterCuts::operator=(rhs);
    IFilter<T>::operator=(rhs);
    m_pxRange   = rhs.m_pxRange;
    m_pyRange   = rhs.m_pyRange;
    m_pzRange   = rhs.m_pzRange;
    m_eneRange  = rhs.m_eneRange;
    m_etaRange  = rhs.m_etaRange;
    m_phiRange  = rhs.m_phiRange;
    m_massRange = rhs.m_massRange;
    m_ptRange   = rhs.m_ptRange;
  }
  return *this;
}
 
// Const methods: 
 
template<typename T>
bool MomentumFilter<T>::isAccepted( const T * element ) const
{
  bool isAccepted = true;
  
  if ( m_pxRange.isActive() ) {
    isAccepted = isAccepted && m_pxRange.isInRange  ( element->px()  );
  }
  if ( m_pyRange.isActive() ) {
    isAccepted = isAccepted && m_pyRange.isInRange  ( element->py()  );
  }
  if ( m_pzRange.isActive() ) {
    isAccepted = isAccepted && m_pzRange.isInRange  ( element->pz()  );
  }
  if ( m_eneRange.isActive() ) {
    isAccepted = isAccepted && m_eneRange.isInRange ( element->e()   );
  }
  if ( m_etaRange.isActive() ) {
    isAccepted = isAccepted && m_etaRange.isInRange ( element->eta() );
  }
  if ( m_phiRange.isActive() ) {
    isAccepted = isAccepted && m_phiRange.isInRange( element->phi() );
  }
  if ( m_massRange.isActive() ) {
    isAccepted = isAccepted && m_massRange.isInRange( element->m()   );
  }
  if ( m_ptRange.isActive() ) {
    isAccepted = isAccepted && m_ptRange.isInRange  ( element->pt()  );
  }
 
  return isAccepted;
}
 
template<typename T>
inline double MomentumFilter<T>::pxMin() const
{
  return m_pxRange.lower();
}
 
template<typename T>
inline double MomentumFilter<T>::pxMax() const
{
  return m_pxRange.upper();
}
 
template<typename T>
inline double MomentumFilter<T>::pyMin() const
{
  return m_pyRange.lower();
}
 
template<typename T>
inline double MomentumFilter<T>::pyMax() const
{
  return m_pyRange.upper();
}
 
template<typename T>
inline double MomentumFilter<T>::pzMin() const
{
  return m_pzRange.lower();
}
 
template<typename T>
inline double MomentumFilter<T>::pzMax() const
{
  return m_pzRange.upper();
}
 
template<typename T>
inline double MomentumFilter<T>::eneMin() const
{
  return m_eneRange.lower();
}
 
template<typename T>
inline double MomentumFilter<T>::eneMax() const
{
  return m_eneRange.upper();
}
 
template<typename T>
inline double MomentumFilter<T>::etaMin() const
{
  return m_etaRange.lower();
}
 
template<typename T>
inline double MomentumFilter<T>::etaMax() const
{
  return m_etaRange.upper();
}
 
template<typename T>
inline double MomentumFilter<T>::phiMin() const
{
  return m_phiRange.lower();
}
 
template<typename T>
inline double MomentumFilter<T>::phiMax() const
{
  return m_phiRange.upper();
}
 
template<typename T>
inline double MomentumFilter<T>::massMin() const
{
  return m_massRange.lower();
}
 
template<typename T>
inline double MomentumFilter<T>::massMax() const
{
  return m_massRange.upper();
}
 
template<typename T>
inline double MomentumFilter<T>::ptMin() const
{
  return m_ptRange.lower();
}
 
template<typename T>
inline double MomentumFilter<T>::ptMax() const
{
  return m_ptRange.upper();
}
 
template<typename T>
inline double MomentumFilter<T>::atlasPhi( const double phi ) const
{
  return m_phiRange.atlasPhi( phi );
}
 
// Non-const methods: 
template<typename T>
void MomentumFilter<T>::setFilter( const IFilterCuts * filter )
{
  if ( filter ) {
    try {
      const MomentumFilter<T> * momFilter = 
    dynamic_cast<const MomentumFilter<T> *>(filter);
 
      if ( momFilter ) {
    operator=(*momFilter);
      } else {
    MsgStream log( Athena::getMessageSvc(), "MomentumFilter" );
    log << MSG::ERROR
        << "Can't dynamic_cast " << typeid(filter).name() 
        << " to a MomentumFilter"
        << endmsg;
      }
    } catch (...) {
      MsgStream log( Athena::getMessageSvc(), "MomentumFilter" );
      log << MSG::ERROR
      << "Can't dynamic_cast " << filter << " to a MomentumFilter"
      << endmsg;
    }
  } //> filter is a valid pointer
}
 
template<typename T>
inline void MomentumFilter<T>::setPxMin( const double pxMin )
{
  m_pxRange.setMin(pxMin);
}
 
template<typename T>
inline void MomentumFilter<T>::setPxMax( const double pxMax )
{
  m_pxRange.setMax(pxMax);
}
 
template<typename T>
inline void MomentumFilter<T>::setPyMin( const double pyMin )
{
  m_pyRange.setMin(pyMin);
}
 
template<typename T>
inline void MomentumFilter<T>::setPyMax( const double pyMax )
{
  m_pyRange.setMax(pyMax);
}
 
template<typename T>
inline void MomentumFilter<T>::setPzMin( const double pzMin )
{
  m_pzRange.setMin(pzMin);
}
 
template<typename T>
inline void MomentumFilter<T>::setPzMax( const double pzMax )
{
  m_pzRange.setMax(pzMax);
}
 
template<typename T>
inline void MomentumFilter<T>::setEneMin( const double eneMin )
{
  m_eneRange.setMin(eneMin);
}
 
template<typename T>
inline void MomentumFilter<T>::setEneMax( const double eneMax )
{
  m_eneRange.setMax(eneMax);
}
 
template<typename T>
inline void MomentumFilter<T>::setEtaMin( const double etaMin )
{
  m_etaRange.setMin(etaMin);
}
 
template<typename T>
inline void MomentumFilter<T>::setEtaMax( const double etaMax )
{
  m_etaRange.setMax(etaMax);
}
 
template<typename T>
inline void MomentumFilter<T>::setPhiMin( const double phiMin )
{
  m_phiRange.setMin(phiMin);
}
 
template<typename T>
inline void MomentumFilter<T>::setPhiMax( const double phiMax )
{
  m_phiRange.setMax(phiMax);
}
 
template<typename T>
inline void MomentumFilter<T>::setMassMin( const double massMin )
{
  m_massRange.setMin(massMin);
}
 
template<typename T>
inline void MomentumFilter<T>::setMassMax( const double massMax )
{
  m_massRange.setMax(massMax);
}
 
template<typename T>
inline void MomentumFilter<T>::setPtMin( const double ptMin )
{
  m_ptRange.setMin(ptMin);
}
 
template<typename T>
inline void MomentumFilter<T>::setPtMax( const double ptMax )
{
  m_ptRange.setMax(ptMax);
}
 
template<typename T>
void MomentumFilter<T>::setRange( const std::string& name,
                  const double min, const double max )
{
  if        ( name == "px" )   { m_pxRange   .setRange( min, max );
  } else if ( name == "py" )   { m_pyRange   .setRange( min, max );
  } else if ( name == "pz" )   { m_pzRange   .setRange( min, max );
  } else if ( name == "ene" )  { m_eneRange  .setRange( min, max );
  } else if ( name == "eta" )  { m_etaRange  .setRange( min, max );
  } else if ( name == "phi" )  { m_phiRange  .setRange( min, max );
  } else if ( name == "mass" ) { m_massRange .setRange( min, max );
  } else if ( name == "pt" )   { m_ptRange   .setRange( min, max );
  } else {
    const std::string error = "Range of name <"+name+"> is UNKNOWN !!";
    throw std::invalid_argument(error);
  }
 
  return;
}
 
#endif //> ANALYSISUTILS_MOMENTUMFILTER_H