TauJet_v2.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
*/
 
// $Id: TauJet_v2.h 747258 2016-05-15 02:57:19Z griffith $
#ifndef XAODTAU_VERSIONS_TAUJET_V2_H
#define XAODTAU_VERSIONS_TAUJET_V2_H
 
 
// Core include(s):
#include "AthLinks/ElementLink.h"
 
 
// xAOD include(s):
#include "xAODBase/IParticle.h"
#include "xAODBase/IParticleContainer.h"
#include "xAODTau/TauDefs.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTracking/VertexContainer.h"
#include "xAODJet/JetContainer.h"
#include "xAODPFlow/PFOContainer.h"
 
// ROOT include(s):
#include "Math/Vector4D.h"
 
namespace xAOD {
 
 
 
  class TauJet_v2 : public IParticle {
 
  public:
    TauJet_v2();
    
    
    virtual double           pt() const;
    virtual double           eta() const;
    virtual double           phi() const;
    virtual double           e() const;
    
    virtual double           m() const;
    virtual double           rapidity() const;
    
    virtual FourMom_t p4() const;
    virtual FourMom_t p4(const TauJetParameters::TauCalibType calib) const;
 
    typedef ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double> > GenVecFourMom_t;
 
    GenVecFourMom_t genvecP4() const; 
    GenVecFourMom_t genvecP4(const TauJetParameters::TauCalibType calib) const; 
 
    void setP4(double pt, double eta, double phi, double m);
    bool setP4(const TauJetParameters::TauCalibType calib, double pt, double eta, double phi, double m);
 
    //setters and getters for the individual 4-vector components at different calibration levels
    double ptJetSeed() const;
    double etaJetSeed() const;
    double phiJetSeed() const;
    double mJetSeed() const;
 
    double ptDetectorAxis() const;
    double etaDetectorAxis() const;
    double phiDetectorAxis() const;
    double mDetectorAxis() const;
 
    double ptIntermediateAxis() const;
    double etaIntermediateAxis() const;
    double phiIntermediateAxis() const;
    double mIntermediateAxis() const;
 
    double ptTauEnergyScale() const;
    double etaTauEnergyScale() const;
    double phiTauEnergyScale() const;
    double mTauEnergyScale() const;
 
    double ptTauEtaCalib() const;
    double etaTauEtaCalib() const;
    double phiTauEtaCalib() const;
    double mTauEtaCalib() const;
 
    double ptPanTauCellBasedProto() const;
    double etaPanTauCellBasedProto() const;
    double phiPanTauCellBasedProto() const;
    double mPanTauCellBasedProto() const;
 
    double ptPanTauCellBased() const;
    double etaPanTauCellBased() const;
    double phiPanTauCellBased() const;
    double mPanTauCellBased() const;
 
    double ptTrigCaloOnly() const;
    double etaTrigCaloOnly() const;
    double phiTrigCaloOnly() const;
    double mTrigCaloOnly() const;
 
    virtual Type::ObjectType type() const;
    
 
    // the summed up charge of all tau tracks
    float charge() const;
 
    // set the charge
    void setCharge(float);
 
    unsigned int ROIWord() const;
 
    // set the ROIWord, needed by TauTrigger 
    void setROIWord(unsigned int);
 
    bool hasDiscriminant( TauJetParameters::TauID discID ) const;
    
    double discriminant( TauJetParameters::TauID discID ) const;
 
    void setDiscriminant( TauJetParameters::TauID discID, double disc );
 
    bool isTau( TauJetParameters::IsTauFlag flag ) const;
 
    void setIsTau( TauJetParameters::IsTauFlag flag, bool value );
 
    void setFlag( TauJetParameters::VetoFlags flag, bool value );
 
    bool flag( TauJetParameters::VetoFlags flag ) const;
 
 
    bool detail( TauJetParameters::Detail detail, int& value ) const;
    bool detail( TauJetParameters::Detail detail, float& value ) const;
    void setDetail( TauJetParameters::Detail detail, int value );
    void setDetail( TauJetParameters::Detail detail, float value );
 
    // getter for specialized types. Compilation error if used with other types.
    template <class T>
    typename xAODTAU_return_type<T>::type detail( TauJetParameters::Detail detail ) const
    {
        T temp;
        if (this->detail(detail,temp)) return temp;
        else return 0;
    }
 
    bool panTauDetail( TauJetParameters::PanTauDetails panTauDetail, int& value ) const;
    bool panTauDetail( TauJetParameters::PanTauDetails panTauDetail, float& value ) const;
    void setPanTauDetail( TauJetParameters::PanTauDetails panTauDetail, int value );
    void setPanTauDetail( TauJetParameters::PanTauDetails panTauDetail, float value );
 
    // getter for specialized types. Compilation error if used with other types.
    template <class T>
    typename xAODTAU_return_type<T>::type panTauDetail( TauJetParameters::PanTauDetails panTauDetail ) const
    {
        T temp;
        if (this->panTauDetail(panTauDetail,temp)) return temp;
        else return 0;
    }
 
    //seed jet
    typedef ElementLink< xAOD::JetContainer > JetLink_t;
 
    const JetLink_t& jetLink() const;
    
    void setJetLink( const JetLink_t& jetLink ); 
 
    void setJet( const xAOD::JetContainer *cont, const xAOD::Jet *jet ); 
 
    const Jet* jet() const;
 
  
    //vertex that the tau comes from
    typedef ElementLink< xAOD::VertexContainer > VertexLink_t;
 
    const VertexLink_t& vertexLink() const;
    
    void setVertexLink( const VertexLink_t& vertexLink ); 
 
    void setVertex( const xAOD::VertexContainer *cont, const xAOD::Vertex *vertex ); 
 
    const Vertex* vertex() const;
 
 
    //secondary vertex that the tau decays in
 
    const VertexLink_t& secondaryVertexLink() const;
    
    void setSecondaryVertexLink( const VertexLink_t& vertexLink ); 
 
    void setSecondaryVertex( const xAOD::VertexContainer *cont, const xAOD::Vertex *vertex ); 
 
    const Vertex* secondaryVertex() const;
  
 
    //tracks
    typedef std::vector< ElementLink< xAOD::TrackParticleContainer > >  TrackParticleLinks_t;
   
    const TrackParticleLinks_t& trackLinks() const;
 
    void setTrackLinks( const TrackParticleLinks_t& trackParticles );
    const TrackParticle* track( size_t i ) const;
    // /// Get the number of track particles associated with this tau
    size_t nTracks() const;
    void addTrackLink( const ElementLink< TrackParticleContainer >& tr);
    void clearTrackLinks();
    
    // Get and set track flags
    bool trackFlag(const TrackParticle* track, TauJetParameters::TauTrackFlag flag) const;
    void setTrackFlag(const TrackParticle* track, TauJetParameters::TauTrackFlag flag, bool value);
 
    //name accessors for trackFilterProngs
    int trackFilterProngs() const;
    //name accessors for trackFilterProngs
    void setTrackFilterProngs(int);
 
    //name accessors for trackFilterQuality
    int trackFilterQuality() const;
    //name accessors for trackFilterQuality
    void setTrackFilterQuality(int);
 
    //name accessors for pi0ConeDR
    float pi0ConeDR() const;
    //name accessors for pi0ConeDR
    void setPi0ConeDR(float);
 
 
    //name accessors for trackEtaStrip
    float trackEtaStrip(unsigned int numTrack) const;
    //name accessors for trackEtaStrip
    void setTrackEtaStrip(unsigned int numTrack, float eta);
 
 
    //name accessors for trackPhiStrip
    float trackPhiStrip(unsigned int numTrack) const;
    //name accessors for trackPhiStrip
    void setTrackPhiStrip(unsigned int numTrack, float phi);
 
 
    //wide tracks
    const TrackParticleLinks_t& wideTrackLinks() const;
    
    void setWideTrackLinks( const TrackParticleLinks_t& trackParticles );
    const TrackParticle* wideTrack( size_t i ) const;
    size_t nWideTracks() const;
    void addWideTrackLink( const ElementLink< TrackParticleContainer >& tr);
    void clearWideTrackLinks();
 
 
    //other tracks
    const TrackParticleLinks_t& otherTrackLinks() const;
    
    void setOtherTrackLinks( const TrackParticleLinks_t& trackParticles );
    const TrackParticle* otherTrack( size_t i ) const;
    size_t nOtherTracks() const;
    void addOtherTrackLink( const ElementLink< TrackParticleContainer >& tr);
    void clearOtherTrackLinks();
 
 
 
    typedef std::vector< ElementLink< xAOD::PFOContainer > >  PFOLinks_t;
 
 
    //photon shot PFOs
    const PFOLinks_t& hadronicPFOLinks() const;
 
    void setHadronicPFOLinks( const PFOLinks_t& hadronicPFOs );
    const PFO* hadronicPFO( size_t i ) const;
    size_t nHadronicPFOs() const;
    void addHadronicPFOLink( const ElementLink< PFOContainer >& pfo);
    void clearHadronicPFOLinks();
 
 
    //photon shot PFOs
    const PFOLinks_t& shotPFOLinks() const;
 
    void setShotPFOLinks( const PFOLinks_t& shotPFOs );
    const PFO* shotPFO( size_t i ) const;
    size_t nShotPFOs() const;
    void addShotPFOLink( const ElementLink< PFOContainer >& pfo);
    void clearShotPFOLinks();
 
 
    //
    //charged PFOs
    const PFOLinks_t& chargedPFOLinks() const;
 
    void setChargedPFOLinks( const PFOLinks_t& chargedPFOs );
    const PFO* chargedPFO( size_t i ) const;
    size_t nChargedPFOs() const;
    void addChargedPFOLink( const ElementLink< PFOContainer >& pfo);
    void clearChargedPFOLinks();
 
 
    //neutral PFOs
    const PFOLinks_t& neutralPFOLinks() const;
 
    void setNeutralPFOLinks( const PFOLinks_t& neutralPFOs );
    const PFO* neutralPFO( size_t i ) const;
    size_t nNeutralPFOs() const;
    void addNeutralPFOLink( const ElementLink< PFOContainer >& pfo);
    void clearNeutralPFOLinks();
 
 
    //pi0 PFOs
    const PFOLinks_t& pi0PFOLinks() const;
 
    void setPi0PFOLinks( const PFOLinks_t& pi0PFOs );
    const PFO* pi0PFO( size_t i ) const;
    size_t nPi0PFOs() const;
    void addPi0PFOLink( const ElementLink< PFOContainer >& pfo);
    void clearPi0PFOLinks();
 
 
 
 
    //
    //cellbased_charged PFOs
    const PFOLinks_t& protoChargedPFOLinks() const;
 
    void setProtoChargedPFOLinks( const PFOLinks_t& protoChargedPFOs );
    const PFO* protoChargedPFO( size_t i ) const;
    size_t nProtoChargedPFOs() const;
    void addProtoChargedPFOLink( const ElementLink< PFOContainer >& pfo);
    void clearProtoChargedPFOLinks();
 
 
    //cellbased_neutral PFOs
    const PFOLinks_t& protoNeutralPFOLinks() const;
 
    void setProtoNeutralPFOLinks( const PFOLinks_t& protoNeutralPFOs );
    const PFO* protoNeutralPFO( size_t i ) const;
    size_t nProtoNeutralPFOs() const;
    void addProtoNeutralPFOLink( const ElementLink< PFOContainer >& pfo);
    void clearProtoNeutralPFOLinks();
 
 
    //pi0 PFOs
    const PFOLinks_t& protoPi0PFOLinks() const;
 
    void setProtoPi0PFOLinks( const PFOLinks_t& protoPi0PFOs );
    const PFO* protoPi0PFO( size_t i ) const;
    size_t nProtoPi0PFOs() const;
    void addProtoPi0PFOLink( const ElementLink< PFOContainer >& pfo);
    void clearProtoPi0PFOLinks();
 
 
  
    
 
    void dump() const;
 
 
  }; // class TauJet
 
} // namespace xAOD
 
 
// Declare IParticle as a base class of TauJet_v2:
#include "AthContainers/DataVector.h"
DATAVECTOR_BASE( xAOD::TauJet_v2, xAOD::IParticle );
 
#endif // XAODTAU_VERSIONS_TAUJET_V2_H
 
//  LocalWords:  newROIWord