JetConstituentIterator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef JETEVENT_JETCONSTITUENTITERATOR_H
#define JETEVENT_JETCONSTITUENTITERATOR_H
 
 
#include "FourMom/P4PxPyPzE.h"
 
#include "NavFourMom/INavigable4MomentumCollection.h"
 
#include "JetEvent/Jet.h"
 
 
class JetConstituentIterator : public P4PxPyPzE {
 public:
 
  typedef Jet::const_iterator base_it;
  
  JetConstituentIterator( base_it b): m_actual(b), m_end(b), m_use_signal_state(false), m_defState(P4SignalState::UNKNOWN), m_curState(m_defState)
    {
      m_end.end();
      update_hlv();
    }
  
  JetConstituentIterator( base_it b, P4SignalState::State s): m_actual(b),m_end(b),  m_use_signal_state(true), m_defState(s), m_curState(m_defState)
    {    m_end.end(); update_hlv();}
  
  // operators ------------------------------------------------
  JetConstituentIterator& operator++ (){
    m_actual++;
    update_hlv();
    return *this;
  }
  
  JetConstituentIterator& operator-- (){
    m_actual--;
    update_hlv();
    return *this;
  }
 
  // for python, we alias operator++/--
  void inc(){ this->operator++();}
  void dec(){ this->operator--();}
  
  const JetConstituentIterator * operator*() const {    return this; }
  
  bool operator== (const JetConstituentIterator& other) const { return (m_actual == other.m_actual) ; }
  
  bool operator!= (const JetConstituentIterator& other) const { return (m_actual != other.m_actual) ; }
  // ------------------------------------------------------------
  
  const Jet::constituent_t* get_real_constit(){ return *m_actual ;}
  
  
  P4SignalState::State getSignalState();
  void setSignalState(P4SignalState::State s);
  
  
  // Static functions -------------------------------------------
  static JetConstituentIterator first(const Jet * jet){
    Jet::const_iterator begin = jet->begin();
    if( begin == jet->end() ) return JetConstituentIterator(begin);            
    P4SignalState::State constituentDef = getSignalState(*begin);
    if( (constituentDef == jet->constituentSignalState())  ||  // if default state is same as the one in jet
        (constituentDef == P4SignalState::UNKNOWN ) )          // or has no sigstate
      return JetConstituentIterator(begin);             // -> use the fast version
    else
      return JetConstituentIterator(begin, jet->constituentSignalState()); // else default to state in jet
  }
  static JetConstituentIterator first(const Jet * jet, P4SignalState::State s){
    return JetConstituentIterator(jet->begin(), s);
  }
  static JetConstituentIterator last(const Jet * jet){
    return JetConstituentIterator(jet->end());
  }
  static P4SignalState::State getSignalState(const Jet::constituent_t *constit); 
  // -------------------------------------------------------------
  
 protected:
  
  base_it m_actual;
  base_it m_end;
  Jet::hlv_t   m_hlv;
  bool m_use_signal_state;
  P4SignalState::State m_defState;
  P4SignalState::State m_curState;
  
  void update_hlv();
 
};
#endif