ChargeFilter.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// ChargeFilter.h 
// Header file for class ChargeFilter
// Author: S.Binet<binet@cern.ch>
#ifndef ANALYSISUTILS_CHARGEFILTER_H 
#define ANALYSISUTILS_CHARGEFILTER_H 
 
// FrameWork includes
#include "AthenaKernel/getMessageSvc.h"
#include "GaudiKernel/MsgStream.h"
#include <optional>
 
// EventKernel includes
#include "EventKernel/IParticle.h"
 
// AnalysisUtils includes
#include "AnalysisUtils/IFilter.h"
 
template <typename T>
class ChargeFilter : virtual public IFilter<T>
{ 
 
  // Public methods: 
 public: 
 
  ChargeFilter();
 
  ChargeFilter( const ChargeFilter<T>& rhs );
 
  // Constructor with parameters: 
 
  virtual ~ChargeFilter(); 
 
  ChargeFilter<T>& operator=( const ChargeFilter<T>& rhs ); 
 
  // Const methods: 
 
  virtual bool isAccepted( const T * element ) const;
 
  double charge() const;
  
  // Non-const methods: 
 
  void setFilter( const IFilterCuts * filter );
 
  void setCharge( const ChargeType& charge );
 
  // Protected data: 
 protected: 
 
  std::optional<ChargeType> m_charge;
 
}; 
 
template<typename T>
ChargeFilter<T>::ChargeFilter() :
  IFilterCuts(),
  IFilter<T>(),
  m_charge()
{}
 
template<typename T>
ChargeFilter<T>::ChargeFilter( const ChargeFilter<T>& rhs ) :
  IFilterCuts(rhs),
  IFilter<T>(rhs),
  m_charge(rhs.m_charge)
{}
 
template<typename T>
inline 
ChargeFilter<T>& ChargeFilter<T>::operator=( const ChargeFilter<T>& rhs ) 
{
  if ( this != &rhs ) {
    IFilterCuts::operator=(rhs);
    IFilter<T>::operator=(rhs);
    m_charge = rhs.m_charge;
  }
  return *this;
}
 
 
template<typename T>
ChargeFilter<T>::~ChargeFilter(){}
 
template<typename T>
bool ChargeFilter<T>::isAccepted( const T * element ) const
{
  if ( !m_charge ) {
    return true;
  } else {
    const ChargeType charge = element->charge();
    if ( *m_charge == charge ) { 
      return true;
    } else { 
      return false; 
    }
  }
 
  return true;
}
 
template<typename T>
double ChargeFilter<T>::charge() const
{
  if (m_charge) {
    return *m_charge;
  }
  throw std::domain_error( "No charge selection defined" );
}
 
template<typename T>
void ChargeFilter<T>::setFilter( const IFilterCuts * filter )
{
  if ( filter ) {
    const ChargeFilter<T> * chFilter =
      dynamic_cast<const ChargeFilter<T> *>(filter);
    if ( chFilter ) {
      operator=(*chFilter);
    } else {
      MsgStream log( Athena::getMessageSvc(), "ChargeFilter" );
      log << MSG::ERROR
      << "Can't dynamic_cast " << typeid(filter).name() 
      << " to a ChargeFilter"
      << endmsg;
    }
  }
}
 
template<typename T>
void ChargeFilter<T>::setCharge( const ChargeType& charge )
{
  m_charge = charge;
}
 
#endif //> ANALYSISUTILS_CHARGEFILTER_H