AncestorFinder.h

Go to the documentation of this file.

 
 
#ifndef   IDTPM2_ANCESTORFINDER_H
#define   IDTPM2_ANCESTORFINDER_H
 
#include "ConfiguredValue.h"
 
#include <cmath>
 

 
namespace IDTPM2 { 
 
template<typename T> 
class IFinder  { 
 
public:
  
  virtual ~IFinder() = default; 
 
  const T* findAncestor(const T* t) const {
 
    // reached the end ...
    if (!t) return 0;

    if ( predicate(t) ) return t;
 
    for ( size_t p=0 ; p<t->nParents() ; p++ ) {
        const T* parent = t->parent(p);
 
        if ( parent==t ) continue;

        if ( const T* found = findAncestor(parent) ) return found;
    }
 
    return 0;
  }
 
  virtual bool predicate( const T* t ) const = 0;
    
};
 
 

 
template<typename T, typename Predicate>
class GenericAncestorFinder : public IFinder<T> {
  
public:
  
  GenericAncestorFinder( Predicate p ) : m_predicate(p) { }   
 
  bool predicate( const T* t ) const override { return m_predicate(t); } 
  
private:
 
  Predicate m_predicate;
  
};
 
 

 
template<typename T>
class IPredicate {
public:
  virtual ~IPredicate() {}
  virtual bool operator()(const T* t) const = 0;
};
  
 

 
template<typename T>
class PdgIdHelper : public IPredicate<T> {
 
public:
 
  PdgIdHelper(int pdgid) : m_pdgid(std::abs(pdgid)) {}

  bool operator()(const T* t) const { return std::abs(t->pdgId()) == m_pdgid; }
 
private:
 
  int m_pdgid;
 
};
 
 
 
template<typename T>
class PtHelper : public IPredicate<T> {
 
public:
 
  PtHelper( ConfiguredValue<float> pt={} ) : m_pt(pt) {}

  bool operator()(const T* t) const {
    if ( std::abs(t->pt()) < m_pt ) return false;
    return true;
  }
 
private:
 
  ConfiguredValue<float> m_pt;
 
};
 
  
template<typename T, typename U=T>
class PtPdgIdHelper : public IPredicate<T> {
 
public:
 
  PtPdgIdHelper( ConfiguredValue<float> pt={}, const ConfiguredValue<int> pdgid={}) :
    m_pt(pt), m_pdgid(pdgid) {}

  bool operator()(const T* t) const {
    if ( std::abs(t->pt()) < m_pt ) return false;
    if ( std::abs(t->template as<U>()->pdgId()) != m_pdgid ) return false;
    return true;
  }
 
private:
 
  ConfiguredValue<float> m_pt;
  ConfiguredValue<int>   m_pdgid;
 
};
 
  
 
 
 
template<typename T>
class PdgAncestorFinder : public GenericAncestorFinder<T, PdgIdHelper<T>> {
public:
  PdgAncestorFinder( int i ) : GenericAncestorFinder<T, PdgIdHelper<T> >( PdgIdHelper<T>(i)) { }
};
 
 
 
 
 
template<typename T, typename P=bool (*)(const T*)>
class PredicateAncestorFinder : public GenericAncestorFinder<T, P> {
public:
  PredicateAncestorFinder( P p ) : GenericAncestorFinder<T, P>(p) { }
};
 
 
 

 
template<typename T>
class HadronAncestorFinder : public IFinder<T> {
 
public:
  
  using Predicate = bool (T::*)() const;
  
  HadronAncestorFinder( Predicate p ) : m_predicate(p) { }   
  
  bool predicate( const T* t ) const override { return (t->*m_predicate)(); } 
  
private:
 
  Predicate m_predicate;
  
};
 
 
} // namespace IDTPM2
 
 
#endif  // IDTPM2_ANCESTORFINDER_H