JetConstituentVector.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#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 IParticle::FourMom_t 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) const;
      bool operator!=( const iterator & other) const;
 
      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