CaloTag.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONCOMBINEDEVENT_CALOTAG_H
#define MUONCOMBINEDEVENT_CALOTAG_H
 
#include <vector>
 
#include "MuonCombinedEvent/TagBase.h"
#include "TrkMaterialOnTrack/EnergyLoss.h"
#include "muonEvent/DepositInCalo.h"
 
namespace MuonCombined {
 
    class CaloTag : public TagBase, public Trk::EnergyLoss {
    public:
        enum EnergyLossType { Parametrized = 0, NotIsolated = 1, MOP = 2, Tail = 3, FSRcandidate = 4 };
 
        CaloTag(void);
 
        CaloTag(const Trk::EnergyLoss& eloss);
 
        CaloTag(xAOD::Muon::Author author, float deltaE, float sigmaDeltaE, float sigmaMinusDeltaE = 0.0, float sigmaPlusDeltaE = 0.0,
                unsigned short energyLossType = 0, float likelihood = 0, float muonScore = 0, unsigned short tag = 0);
 
        CaloTag(xAOD::Muon::Author author, float deltaE, float sigmaDeltaE, float sigmaMinusDeltaE, float sigmaPlusDeltaE,
                unsigned short energyLossType, float likelihood, float muonScore, unsigned short tag,
                const std::vector<DepositInCalo>& deposits);
 
        ~CaloTag();
 
        std::string name() const { return "CaloTag"; }
 
        std::string toString() const { return name(); }
        CaloTag::EnergyLossType energyLossType(void) const;
 
        unsigned short caloMuonIdTag() const { return m_caloMuonIdTag; }
 
        double caloLRLikelihood() const { return m_caloLRLikelihood; }
 
        double caloMuonScore() const { return m_caloMuonScore; }
 
        const std::vector<DepositInCalo>& depositInCalo() const { return m_deposits; }
 
        float fsrCandidateEnergy() const { return m_fsrCandidateEnergy; }
 
        float etCore() const { return m_etCore; }
 
        void set_energyLossType(const CaloTag::EnergyLossType lossType) { m_energyLossType = lossType; }
 
        void set_caloLRLikelihood(const float likelihood) { m_caloLRLikelihood = likelihood; }
 
        void set_caloMuonScore(const float muonScore) { m_caloMuonScore = muonScore; }
 
        void set_caloMuonIdTag(unsigned short tag) { m_caloMuonIdTag = tag; }
 
        void set_deposits(const std::vector<DepositInCalo>& deposits) { m_deposits = deposits; }
 
        void insert_deposit(const DepositInCalo& deposit) { m_deposits.push_back(deposit); }
 
        void set_fsrCandidateEnergy(const float fs) { m_fsrCandidateEnergy = fs; }
 
        void set_etCore(const float etcore) { m_etCore = etcore; }
 
        Author author2() const { return m_author2; }
 
        Author author3() const { return m_author3; }
 
        void set_author2(const Author author2) { m_author2 = author2; }
 
        void set_author3(const Author author3) { m_author3 = author3; }
 
    private:
        CaloTag(const CaloTag&) = delete;
        CaloTag& operator=(const CaloTag&) = delete;
 
        EnergyLossType m_energyLossType;
        float m_caloLRLikelihood;
        float m_caloMuonScore;
        unsigned short m_caloMuonIdTag;
        float m_fsrCandidateEnergy;
        std::vector<DepositInCalo> m_deposits;
        float m_etCore;    // summed cell ET in core DeltaR
        Author m_author2;  // in case of tag by more than one algorithm
        Author m_author3;  // in case of tag by all three algorithms
    };
    inline CaloTag::EnergyLossType CaloTag::energyLossType(void) const { return m_energyLossType; }
 
    // should be blocked ?
    // inline CaloTag* CaloTag::clone() const
    // { return new CaloTag(*this); }
 
}  // namespace MuonCombined
 
#endif