Jet_v1.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#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"
 
// Local include(s):
//#include "xAODJet/JetConstituentIterator.h"
#include "xAODJet/JetConstituentVector.h"
#include "xAODJet/JetAttributes.h"
#include "xAODJet/JetTypes.h"
#include "xAODJet/JetContainerInfo.h"
 
#include "xAODJet/JetContainerFwd.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 FourMom_t p4() const;
 
 
    virtual Type::ObjectType type() const;
 
 
 
 
 
    typedef JetFourMom_t GenVecFourMom_t;
 
 
    JetFourMom_t jetP4() const;
    JetFourMom_t genvecP4() const;
 
    float px() const;
    float py() const;
    float pz() const;
 
 
 
    JetFourMom_t jetP4(JetScale s) const ;
    JetFourMom_t genvecP4(JetScale s) const ;
    JetFourMom_t jetP4(const std::string& statename) const ;
    JetFourMom_t genvecP4(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 );
 
    
 
 
    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();
 
  protected:
    FastJetLinkBase * m_fastJetLink;
 
 
  }; // class Jet
 
 
} // namespace xAOD
 
// Declare IParticle as a base class of Jet_v1:
DATAVECTOR_BASE_FIN( xAOD::Jet_v1, xAOD::IParticle );
 
#include "xAODJet/versions/Jet_v1.icc"
 
#endif // XAODJET_VERSIONS_JET_V1_H