/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODJet/xAODJet/JetConstituentVector.h

// Dear emacs, this is -*- c++ -*-
#ifndef XAODJET_JETCONSTITUENTSVECTOR_H
#define XAODJET_JETCONSTITUENTSVECTOR_H
//   use JetConstituentVector::asSTLVector(). 
 

// Core include(s):
#include "AthLinks/ElementLink.h"

// xAOD include(s):
#include "xAODBase/IParticle.h"
#include "xAODBase/IParticleContainer.h"

#include "xAODJet/JetTypes.h"

namespace xAOD {
  
  class JetConstituent : public xAOD::JetFourMom_t {
  public:
    friend class JetConstituentVector;

    
    JetConstituent(const IParticle* part=0) : xAOD::JetFourMom_t(), m_part(part){}
    
    double           pt() const { return Pt();}
    double           eta() const { return Eta();}
    double           phi() const { return Phi();}
    double           m() const { return M();}
    double           e() const { return E();}
    double           rapidity() const { return Rapidity();}
    
    typedef TLorentzVector FourMom_t;
    
    // 
    //const FourMom_t& p4() const { return FourMom_t(Px(), Py(), Pz(), E());}
 
    
    
    Type::ObjectType type() const { return m_part->type();}

    template< class T >
    const T& auxdata( const std::string& name,
                      const std::string& clsname = "" ) const;

    const JetConstituent* operator->() const {return this;};

    const IParticle* rawConstituent() const { return m_part; }
  protected:
    
    const IParticle * m_part;

  };


  class JetConstituentVector {

  public: 
    
    class iterator {
    public:
      friend class JetConstituentVector;
      typedef std::vector< ElementLink< IParticleContainer > >::const_iterator ELiterator;
      
      iterator(ELiterator it, JetConstitScale s) : m_index(it), m_sigState(s) {}

      iterator & operator++();
      iterator & operator++(int);
      iterator & operator--();
      iterator & operator--(int);
      bool operator==( const iterator & other);
      bool operator!=( const iterator & other);

      const JetConstituent* operator*();
      const JetConstituent* operator->();

      // for python, we alias operator++/--
      void inc(){ this->operator++();}
      void dec(){ this->operator--();}


    protected:


      void update4Mom();
      
      ELiterator m_index;
      ELiterator m_cachedMomIndex;
      JetConstituent m_4mom;

      JetConstitScale m_sigState; 
      
    };

    typedef iterator const_iterator;
    typedef std::vector< ElementLink< IParticleContainer > > ELvector;

    JetConstituentVector(const ELvector* elv , JetConstitScale s ) : m_elVector(elv) , m_sigState(s) {}

    bool isValid() const;


    bool empty() const ;
    size_t size() const ;

    iterator begin() const ;
    iterator end() const ;

    iterator begin(JetConstitScale s) const ;
    iterator end(JetConstitScale s) const ;


    JetConstituent operator[](size_t i) const ;
    JetConstituent at(size_t i) const ;
    JetConstituent front() const ;
    JetConstituent back()  const ;

    std::vector<const IParticle*> asIParticleVector() const ;

    std::vector<JetConstituent> asSTLVector();

  protected:
    
    const std::vector< ElementLink< IParticleContainer > > * m_elVector;
    JetConstitScale m_sigState; 

  };

// Hide the implementation of the template function(s) from gccxml:
#ifndef __GCCXML__


  // use TT as the template parameter to avoid conflicts with LorentzVector::T() !
  template<class TT>  const TT& JetConstituent::auxdata( const std::string& name,
                                    const std::string& clsname ) const {
    return m_part->template auxdata<TT>(name, clsname);
  }


#endif // not __GCCXML__

} // namespace xAOD

#endif

---