Muon_v1.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: Muon_v1.h 745098 2016-05-05 15:47:04Z wleight $
#ifndef XAODMUON_VERSIONS_MUON_V1_H
#define XAODMUON_VERSIONS_MUON_V1_H
 
// Core include(s):
#include "AthContainers/AuxElement.h"
#include "AthLinks/ElementLink.h"
 
//xAOD Primitives
#include "xAODPrimitives/IsolationCorrection.h"
#include "xAODPrimitives/IsolationType.h"
#include "xAODPrimitives/IsolationFlavour.h"
 
// Misc xAOD include(s):
#include "xAODBase/IParticle.h"
#include "xAODTracking/TrackingPrimitives.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODCaloEvent/CaloClusterContainer.h"
#include "xAODMuon/MuonSegmentContainer.h"
 
#include <bitset>
#include <cstdint>
#include <ostream>
#include <string_view>

#define DECLARE_ENUM_OSTREAM(enumType)                            \
    static std::string_view toString(const enumType obj);         \
                                                                  \
    inline friend std::ostream& operator<<(std::ostream& ostr,    \
                                            const enumType obj) { \
      return (ostr<<toString(obj));                               \
    }                                                             \
 
// ROOT include(s):
#include "Math/Vector4D.h"
 
namespace xAOD {
  class Muon_v1 : public IParticle {
 
  public:
    #include "xAODMuon/versions/MuonEnums.def"
    DECLARE_ENUM_OSTREAM(Author);
    DECLARE_ENUM_OSTREAM(MuonType);
    DECLARE_ENUM_OSTREAM(Quality);
    DECLARE_ENUM_OSTREAM(TrackParticleType);
    DECLARE_ENUM_OSTREAM(ParamDef);
    DECLARE_ENUM_OSTREAM(EnergyLossType);
    Muon_v1() = default;

    Muon_v1(const Muon_v1& rhs);

    virtual ~Muon_v1() = default;

    Muon_v1& operator=(const Muon_v1& rhs);

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

    void setP4(double pt, double eta, double phi);

    typedef IParticle::FourMom_t FourMom_t;

    virtual FourMom_t p4() const override;

    typedef ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double> > GenVecFourMom_t;

    GenVecFourMom_t genvecP4() const;

    virtual Type::ObjectType type() const override;

    float charge() const;

    void setCharge(float charge);

    Author author() const;
    bool isAuthor ( const Author author ) const;
    void setAuthor(Author auth);
    uint16_t allAuthors() const;
    void setAllAuthors(uint16_t authors);
    void addAllAuthor( const Author author );


    MuonType muonType() const;
    void setMuonType(MuonType type);

    bool summaryValue(uint8_t& value, const SummaryType information) const;
    void setSummaryValue(uint8_t value, const SummaryType information);
    bool summaryValue(float& value, const SummaryType information) const;
    bool summaryValue(uint8_t& value, const MuonSummaryType information) const;
    void setSummaryValue(uint8_t value, const MuonSummaryType information);

    float floatSummaryValue(const SummaryType information) const;
    uint8_t uint8SummaryValue(const SummaryType information) const;
    float uint8MuonSummaryValue(const MuonSummaryType information) const;

    bool parameter(float& value, const ParamDef parameter) const;

    void setParameter(float value, const ParamDef parameter);

    float floatParameter(const ParamDef parameter) const;

    bool parameter(int& value, const ParamDef parameter) const;

    void setParameter(int value, const ParamDef parameter);

    int intParameter(const ParamDef parameter) const;


    Quality quality() const;
    void setQuality(Quality);

    bool passesIDCuts() const;
    void setPassesIDCuts(bool);



    bool isolation(float& value,   const Iso::IsolationType information) const;

    float isolation(const Iso::IsolationType information) const;

    void setIsolation(float value, const Iso::IsolationType information);

    bool isolationCaloCorrection(float& value, const Iso::IsolationFlavour flavour, const Iso::IsolationCaloCorrection type,
                                 const Iso::IsolationCorrectionParameter param) const;

    float isolationCaloCorrection(const Iso::IsolationFlavour flavour, const Iso::IsolationCaloCorrection type,
                                  const Iso::IsolationCorrectionParameter param) const;

    bool setIsolationCaloCorrection(float value, const Iso::IsolationFlavour flavour, const Iso::IsolationCaloCorrection type,
                                    const Iso::IsolationCorrectionParameter param);
 

    bool isolationTrackCorrection(float& value, const Iso::IsolationFlavour flavour , const Iso::IsolationTrackCorrection type ) const;

    float isolationTrackCorrection(const Iso::IsolationFlavour flavour , const Iso::IsolationTrackCorrection type) const;

    bool setIsolationTrackCorrection(float value, const Iso::IsolationFlavour flavour , const Iso::IsolationTrackCorrection type);
 

    bool isolationCorrectionBitset(std::bitset<32>& value, const Iso::IsolationFlavour flavour ) const;

    std::bitset<32> isolationCorrectionBitset(const Iso::IsolationFlavour flavour ) const;

    bool setIsolationCorrectionBitset(uint32_t value, const Iso::IsolationFlavour flavour );

    const ElementLink< TrackParticleContainer >& primaryTrackParticleLink() const;
    const TrackParticle* primaryTrackParticle() const;

    const ElementLink< TrackParticleContainer >& inDetTrackParticleLink() const;
    const ElementLink< TrackParticleContainer >& muonSpectrometerTrackParticleLink() const;
    const ElementLink< TrackParticleContainer >& combinedTrackParticleLink() const;
    const ElementLink< TrackParticleContainer >& extrapolatedMuonSpectrometerTrackParticleLink() const;
    const ElementLink< TrackParticleContainer >& msOnlyExtrapolatedMuonSpectrometerTrackParticleLink() const;
    const ElementLink< TrackParticleContainer >& trackParticleLink( TrackParticleType type) const;

    void setTrackParticleLink(TrackParticleType type, const ElementLink< TrackParticleContainer >& link);
    const TrackParticle* trackParticle( TrackParticleType type) const;

    const ElementLink<CaloClusterContainer>& clusterLink() const;
    void setClusterLink(const ElementLink<CaloClusterContainer>& link);
    const CaloCluster* cluster() const;

    EnergyLossType energyLossType (void) const;
    void setEnergyLossType (EnergyLossType type) ;


    const std::vector< ElementLink< MuonSegmentContainer > > & muonSegmentLinks() const;
    void setMuonSegmentLinks(const std::vector< ElementLink< MuonSegmentContainer > >& segments) ;
    size_t nMuonSegments() const;
    const MuonSegment* muonSegment( size_t i ) const;
    const ElementLink< MuonSegmentContainer >& muonSegmentLink( size_t i ) const;

  }; // class xAOD::Muon
 
} // namespace xAOD
 
 
#undef DECLARE_ENUM_OSTREAM
// Declare IParticle as a base class of Muon_v1:
#include "AthContainers/DataVector.h"
  DATAVECTOR_BASE( xAOD::Muon_v1, xAOD::IParticle );
 
#endif // XAODMUON_VERSIONS_Muon_v1_H