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

// Dear emacs, this is -*- c++ -*-
#ifndef XAODJET_VERSIONS_JET_V1_H
#define XAODJET_VERSIONS_JET_V1_H

#include <map>


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

// xAOD include(s):
#include "xAODBase/IParticle.h"
#include "xAODBase/IParticleContainer.h"
#ifndef SIMULATIONBASE
#include "xAODBTagging/BTaggingContainer.h"
#endif //SIMULATIONBASE

// Local include(s):
//#include "xAODJet/JetConstituentIterator.h"
#include "xAODJet/JetConstituentVector.h"
#include "xAODJet/JetAttributes.h"
#include "xAODJet/JetTypes.h"
#include "xAODJet/JetContainerInfo.h"

namespace fastjet {
  class PseudoJet;
}

namespace xAOD {
  class FastJetLinkBase; 



  class Jet_v1 : public IParticle {

  public:
    
    typedef JetAttribute::AttributeID AttributeID;
    typedef JetAttribute::AssoParticlesID AssoParticlesID;
    //    typedef P4SignalState::State SignalStateType;

    Jet_v1();
    //Jet_v1( float pt, float eta, float phi, float m );
    Jet_v1(const Jet_v1& );

    ~Jet_v1();

    Jet_v1& operator=(const Jet_v1& other);

    virtual double           pt() const;
    virtual double           eta() const;
    virtual double           phi() const;
    virtual double           m() const;
    virtual double           e() const;
    virtual double           rapidity() const;

    typedef IParticle::FourMom_t FourMom_t;

    virtual const FourMom_t& p4() const;


    virtual Type::ObjectType type() const;





    virtual const JetFourMom_t& jetP4() const;

    float px() const;
    float py() const;
    float pz() const;



    JetFourMom_t jetP4(JetScale s) const ;
    JetFourMom_t jetP4(const std::string& statename) const ;

    void setJetP4(const JetFourMom_t & p4);
    void setJetP4(JetScale s, const JetFourMom_t & p4);

    void setJetP4(const std::string & sname, const JetFourMom_t & p4);

    //Jet_v1* cloneAtState(const std::string& state="") const ;




    //               Constituents 
  public:
    void addConstituent( const ElementLink< IParticleContainer >& link , float weight=1.0 );
    
    void addConstituent( const IParticle* p, float weight=1.0);
    
    JetConstitScale getConstituentsSignalState() const ;
    void setConstituentsSignalState( JetConstitScale t);

    
    JetConstituentVector  getConstituents() const ;
    
    size_t numConstituents() const;

    const IParticle* rawConstituent(size_t i) const ;

    const std::vector< ElementLink< IParticleContainer > >& constituentLinks()const ; 


  protected:
    
    void setNumConstituents(size_t n);

    
    


  public:

    template<class T>
    bool getAttribute( AttributeID type, T & value ) const ;
    template<class T>
    bool getAttribute(const std::string &name, T &value) const;

    template<class T>
    T getAttribute(const std::string &name) const ;
    template<class T>
    T getAttribute(AttributeID type) const ;
    


    template<class T>
    void setAttribute(const std::string &name, const T& v) ;
    template<class T>
    void setAttribute( AttributeID type, const T& value );
#ifndef SIMULATIONBASE
    const BTagging* btagging() const;
    const ElementLink< BTaggingContainer >& btaggingLink() const;
    void setBTaggingLink( const ElementLink< BTaggingContainer>& el );
#endif

    


    template<typename T>
    std::vector<const T*> getAssociatedObjects( const std::string &name) const ;
    template<typename T>
    std::vector<const T*> getAssociatedObjects( AssoParticlesID type) const ;

    template<typename T>
    bool getAssociatedObjects( const std::string &name, std::vector<const T*>& vec) const ;
    template<typename T>
    bool getAssociatedObjects( AssoParticlesID type, std::vector<const T*>& vec) const ;

    template<typename T>
    void setAssociatedObjects( const std::string &name, const std::vector<const T*>& vec) ;
    template<typename T>
    void setAssociatedObjects( AssoParticlesID type, const std::vector<const T*>& vec)  ;


    template<typename T>
    const T* getAssociatedObject( const std::string &name) const ;
    template<typename T>
    const T* getAssociatedObject( AssoParticlesID type) const ;

    template<typename T>
    bool getAssociatedObject( const std::string &name, const T*& vec) const ;
    template<typename T>
    bool getAssociatedObject( AssoParticlesID type, const T*& vec) const ;

    template<typename T>
    void setAssociatedObject( const std::string &name,  const T* vec) ;
    template<typename T>
    void setAssociatedObject( AssoParticlesID type, const T* vec)  ;



    
    


    float getSizeParameter() const ;
    JetAlgorithmType::ID getAlgorithmType() const ;
    JetInput::Type getInputType() const ;

    void setSizeParameter(float p)  ;
    void setAlgorithmType(JetAlgorithmType::ID a)  ;
    void setInputType(JetInput::Type t)  ;


    
    const fastjet::PseudoJet * getPseudoJet() const ;
    template<class PSEUDOJET>
    void setPseudoJet(const PSEUDOJET * fj);
    
    
    void toPersistent();

    void reset();


    

  private:
    mutable FourMom_t m_pxpypze;
    mutable bool m_pxpypzeCached;

    mutable JetFourMom_t m_momentum;
    mutable bool m_momentumCached;

    typedef std::map<std::string, std::vector<const IParticle*> > VectIPartMap_t; 
    mutable VectIPartMap_t m_assoParticleCache;

  protected:
    FastJetLinkBase * m_fastJetLink;


  }; // class Jet


} // namespace xAOD

#include "xAODJet/versions/Jet_v1.icc"

#endif // XAODJET_VERSIONS_JET_V1_H

---