FlavorTagDiscriminants::BTagMuonAugmenter Class Reference

#include <BTagMuonAugmenter.h>

Collaboration diagram for FlavorTagDiscriminants::BTagMuonAugmenter:

Public Member Functions
	BTagMuonAugmenter (const std::string &muonAssociationName, float muonMaxDR=defaults::MUON_MAX_DR, float muonMinpT=defaults::MUON_MIN_PT, FlipTagConfig=FlipTagConfig::STANDARD)
	~BTagMuonAugmenter ()
	BTagMuonAugmenter (BTagMuonAugmenter &&)
void	augment (const xAOD::BTagging &btag) const
std::set< std::string >	getDecoratorKeys () const
std::set< std::string >	getAuxInputKeys () const
std::set< std::string >	getConstituentAuxInputKeys () const

Private Attributes
BTagTrackIpAccessor	m_btag_track_aug
std::string	m_muonAssociationName
float	m_muonMaxDR
float	m_muonMinpT
FlipTagConfig	m_flip_config
AE::ConstAccessor< std::vector< ElementLink< xAOD::MuonContainer > > >	m_acc_assocMuons
AE::ConstAccessor< ElementLink< xAOD::JetContainer > >	m_acc_jetLink
AE::ConstAccessor< float >	m_acc_muon_energyLoss
AE::Decorator< char >	m_dec_muon_isDefaults
AE::Decorator< int >	m_dec_nAssocMuons
AE::Decorator< float >	m_dec_muon_dR
AE::Decorator< float >	m_dec_muon_qOverPratio
AE::Decorator< float >	m_dec_muon_pTrel
AE::Decorator< float >	m_dec_muon_ip3d_d0
AE::Decorator< float >	m_dec_muon_ip3d_z0
AE::Decorator< float >	m_dec_muon_ip3d_d0_significance
AE::Decorator< float >	m_dec_muon_ip3d_z0_significance
AE::Decorator< float >	m_dec_muon_ip3d_sigma_d0
AE::Decorator< float >	m_dec_muon_ip3d_sigma_z0
AE::Decorator< ElementLink< xAOD::MuonContainer > >	m_dec_muon_link
std::vector< std::string >	m_float_IO_variables
std::vector< CAccDec< float > >	m_float_IO
std::vector< std::string >	m_unsigned_char_IO_variables
std::vector< CAccDec< unsigned char > >	m_unsigned_char_IO

Detailed Description

Definition at line 38 of file BTagMuonAugmenter.h.

Constructor & Destructor Documentation

BTagMuonAugmenter() [1/2]

FlavorTagDiscriminants::BTagMuonAugmenter::BTagMuonAugmenter	(	const std::string &	muonAssociationName,
		float	muonMaxDR = defaults::MUON_MAX_DR,
		float	muonMinpT = defaults::MUON_MIN_PT,
		FlipTagConfig	flipConfig = FlipTagConfig::STANDARD
	)

Definition at line 13 of file BTagMuonAugmenter.cxx.

      : m_btag_track_aug("btagIp_"),
        m_muonAssociationName(muonAssociationName),
        m_muonMaxDR(muonMaxDR),
        m_muonMinpT(muonMinpT),
        m_flip_config(flipConfig),
        m_acc_assocMuons(muonAssociationName),
        m_acc_jetLink("jetLink"),
        m_acc_muon_energyLoss("EnergyLoss"),
        m_dec_muon_isDefaults("softMuon_isDefaults"),
        m_dec_nAssocMuons("softMuon_nAssocMuons"),
        m_dec_muon_dR("softMuon_dR"),
        m_dec_muon_qOverPratio("softMuon_qOverPratio"),
        m_dec_muon_pTrel("softMuon_pTrel"),
        m_dec_muon_ip3d_d0("softMuon_ip3dD0"),
        m_dec_muon_ip3d_z0("softMuon_ip3dZ0"),
        m_dec_muon_ip3d_d0_significance("softMuon_ip3dD0Significance"),
        m_dec_muon_ip3d_z0_significance("softMuon_ip3dZ0Significance"),
        m_dec_muon_ip3d_sigma_d0("softMuon_ip3dD0Uncertainty"),
        m_dec_muon_ip3d_sigma_z0("softMuon_ip3dZ0Uncertainty"),
        m_dec_muon_link("softMuon_link"),
        m_float_IO_variables({"pt",
                              "eta",
                              "phi",
                              "momentumBalanceSignificance",
                              "scatteringNeighbourSignificance",
                              "segmentDeltaEta",
                              "segmentDeltaPhi",
                              "ParamEnergyLoss",
                              "ParamEnergyLossSigmaPlus",
                              "ParamEnergyLossSigmaMinus",
                              "MeasEnergyLoss",
                              "MeasEnergyLossSigma",
                              "CaloMuonScore"}),
        m_unsigned_char_IO_variables({"numberOfInnermostPixelLayerHits",
                                      "numberOfInnermostPixelLayerSplitHits",
                                      "numberOfInnermostPixelLayerSharedHits",
                                      "numberOfInnermostPixelLayerOutliers",
                                      "numberOfNextToInnermostPixelLayerHits",
                                      "numberOfNextToInnermostPixelLayerOutliers",
                                      "numberOfPixelHits",
                                      "numberOfPixelSplitHits",
                                      "numberOfPixelSharedHits",
                                      "numberOfPixelSpoiltHits",
                                      "numberOfPixelHoles",
                                      "numberOfSCTHits",
                                      "numberOfSCTSharedHits",
                                      "numberOfSCTHoles",
                                      "expectInnermostPixelLayerHit",
                                      "expectNextToInnermostPixelLayerHit"}) {
    // Fill vectors holding objects that have the const accessors
    // and decorators available as members for each variable
    // that is decorated only.
    for (const std::string& var : m_float_IO_variables) {
      m_float_IO.emplace_back(CAccDec<float>(var));
    }
    for (const std::string& var : m_unsigned_char_IO_variables) {
      m_unsigned_char_IO.emplace_back(CAccDec<unsigned char>(var));
    }
  }

~BTagMuonAugmenter()

FlavorTagDiscriminants::BTagMuonAugmenter::~BTagMuonAugmenter ( )

default

BTagMuonAugmenter() [2/2]

FlavorTagDiscriminants::BTagMuonAugmenter::BTagMuonAugmenter

(

BTagMuonAugmenter &&

)

Member Function Documentation

augment()

void FlavorTagDiscriminants::BTagMuonAugmenter::augment

(

const xAOD::BTagging &

btag

)

const

Definition at line 79 of file BTagMuonAugmenter.cxx.

                                                                {
    BTagSignedIP muon_ip;
    int muon_index = -1;
    float dR_closest_muon = 10;
 
    // set defaults for new variables
    char muon_isDefaults = 1;
    int nAssocMuons = -1;
    float muon_dR = -1;
    float muon_qOverPratio = -1;
    float muon_pTrel = -1;
    float muon_ip3d_d0 = -1;
    float muon_ip3d_z0 = -1;
    float muon_ip3d_d0_significance = -1;
    float muon_ip3d_z0_significance = -1;
    float muon_ip3d_sigma_d0 = -1;
    float muon_ip3d_sigma_z0 = -1;
    ElementLink<xAOD::MuonContainer> muon_link;
 
    // set defaults
    for (auto var : m_float_IO) {
      var.m_dec(btag) = -1;
    }
    for (auto var : m_unsigned_char_IO) {
      var.m_dec(btag) = 0;
    }
 
    // get jet link
    auto jet_link = m_acc_jetLink(btag);
    if (!jet_link.isValid()) {
      throw std::runtime_error("missing jetLink");
    }
    const xAOD::Jet& jet = **jet_link;
 
    // Find associated combined muon closest to jet axis
    std::vector<ElementLink<xAOD::MuonContainer>> assocMuons =
        m_acc_assocMuons(btag);
    if (assocMuons.size() > 0) {
      nAssocMuons = assocMuons.size();
      for (unsigned int imu = 0; imu < assocMuons.size(); imu++) {
        const xAOD::Muon* thisMu = *(assocMuons.at(imu));
        // Check if it's an ID+MS muon
        if (thisMu->muonType() != xAOD::Muon::Combined)
          continue;
 
        // Check minimum muon pT
        if (thisMu->pt() < m_muonMinpT)
          continue;
 
        // Check if it's inside jet
        float dR = jet.p4().DeltaR(thisMu->p4());
        if (dR > m_muonMaxDR)
          continue;
 
        // Check that ID and MS tracks are good
        const xAOD::TrackParticle* IDMuTrack =
            thisMu->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
        const xAOD::TrackParticle* MSMuTrack =
            thisMu->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
        if (!IDMuTrack || !MSMuTrack)
          continue;
 
        // Check quality of muon fit
        float momBalSignif0 = 0;
        thisMu->parameter(momBalSignif0, xAOD::Muon::momentumBalanceSignificance);
        if (momBalSignif0 == 0)
          continue;
        if (MSMuTrack->qOverP() == 0)
          continue;
 
        // Check if this is the closest muon
        if (dR < dR_closest_muon) {
          dR_closest_muon = dR;
          muon_index = imu;
          muon_link = assocMuons.at(imu);
        }
      }
 
      if (muon_index != -1) {
        // Get info for selected muon
        const xAOD::Muon* smtMu = *(assocMuons.at(muon_index));
        const xAOD::TrackParticle* IDMuTrack =
            smtMu->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
 
        // for MCP the ExtrapolatedMuonSpectrometer is standard for MS track
        const xAOD::TrackParticle* MSMuTrack =
            smtMu->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
 
        muon_isDefaults = 0;
        muon_dR = dR_closest_muon;
        muon_qOverPratio = IDMuTrack->qOverP() / MSMuTrack->qOverP();
 
        // calculate ptrel
        // estimate energy loss in transverse direction
        double muon_energyLoss = m_acc_muon_energyLoss(*smtMu);
        // theta is w.r.t z-axis, therefore sin
        double muon_transverseEnergyLoss = muon_energyLoss * std::sin(smtMu->p4().Theta());
        TLorentzVector muon_loss;
        // E ~ P for muons
        muon_loss.SetPtEtaPhiE(muon_transverseEnergyLoss, smtMu->p4().Eta(), jet.p4().Phi(), muon_energyLoss);
        // subtract muon energy loss once, as it is contained in both
        // the muon and the jet.
        TLorentzVector corrected_jet;
        corrected_jet = jet.p4() - muon_loss + smtMu->p4();
        muon_pTrel = smtMu->p4().Vect().Perp(corrected_jet.Vect());
 
        // Muon ID track IP information
        muon_ip = m_btag_track_aug.getSignedIp(*IDMuTrack, jet);
        muon_ip3d_d0 = muon_ip.ip3d_signed_d0;
        muon_ip3d_z0 = muon_ip.ip3d_signed_z0;
        muon_ip3d_d0_significance = muon_ip.ip3d_signed_d0_significance;
        muon_ip3d_z0_significance = muon_ip.ip3d_signed_z0_significance;
        muon_ip3d_sigma_d0 = m_btag_track_aug.d0Uncertainty(*IDMuTrack);
        muon_ip3d_sigma_z0 = m_btag_track_aug.z0SinThetaUncertainty(*IDMuTrack);
 
        // Loop over objects and retrieve the according variable
        // from the smtMu/IDMuTrack object and decorate the btag object
        for (auto var : m_float_IO) {
          var.m_dec(btag) = var.m_acc(*smtMu);
        }
        for (auto var : m_unsigned_char_IO) {
          var.m_dec(btag) = var.m_acc(*IDMuTrack);
        }
      }
    }
    // Decorate btagging object
    m_dec_muon_isDefaults(btag) = muon_isDefaults;
    m_dec_nAssocMuons(btag) = nAssocMuons;
    m_dec_muon_dR(btag) = muon_dR;
    m_dec_muon_qOverPratio(btag) = muon_qOverPratio;
    m_dec_muon_pTrel(btag) = muon_pTrel;
    m_dec_muon_ip3d_d0(btag) = muon_ip3d_d0;
    m_dec_muon_ip3d_z0(btag) = muon_ip3d_z0;
    m_dec_muon_ip3d_d0_significance(btag) = muon_ip3d_d0_significance;
    m_dec_muon_ip3d_z0_significance(btag) = muon_ip3d_z0_significance;
    m_dec_muon_ip3d_sigma_d0(btag) = muon_ip3d_sigma_d0;
    m_dec_muon_ip3d_sigma_z0(btag) = muon_ip3d_sigma_z0;
    m_dec_muon_link(btag) = muon_link;
  }

getAuxInputKeys()

std::set< std::string > FlavorTagDiscriminants::BTagMuonAugmenter::getAuxInputKeys

(

)

const

Definition at line 239 of file BTagMuonAugmenter.cxx.

                                                             {
    const auto& type_registry = SG::AuxTypeRegistry::instance();
    return {
        m_muonAssociationName,
        type_registry.getName(m_acc_jetLink.auxid())};
  }

getConstituentAuxInputKeys()

std::set< std::string > FlavorTagDiscriminants::BTagMuonAugmenter::getConstituentAuxInputKeys

(

)

const

Definition at line 245 of file BTagMuonAugmenter.cxx.

                                                                        {
    return m_btag_track_aug.getTrackIpDataDependencyNames();
  }

getDecoratorKeys()

std::set< std::string > FlavorTagDiscriminants::BTagMuonAugmenter::getDecoratorKeys

(

)

const

Definition at line 219 of file BTagMuonAugmenter.cxx.

                                                              {
    const auto& type_registry = SG::AuxTypeRegistry::instance();
    std::set<std::string> keys;
    for (const auto& auxid : {
             m_dec_muon_isDefaults.auxid(),
             m_dec_muon_dR.auxid(),
             m_dec_muon_qOverPratio.auxid(),
             m_dec_muon_pTrel.auxid(),
             m_dec_muon_ip3d_d0.auxid(),
             m_dec_muon_ip3d_z0.auxid(),
             m_dec_muon_ip3d_d0_significance.auxid(),
             m_dec_muon_ip3d_z0_significance.auxid(),
             m_dec_muon_ip3d_sigma_d0.auxid(),
             m_dec_muon_ip3d_sigma_z0.auxid(),
             m_dec_muon_link.auxid()}) {
      keys.insert(type_registry.getName(auxid));
    }
    return keys;
  }

Member Data Documentation

m_acc_assocMuons

AE::ConstAccessor<std::vector<ElementLink<xAOD::MuonContainer> > > FlavorTagDiscriminants::BTagMuonAugmenter::m_acc_assocMuons

private

Definition at line 59 of file BTagMuonAugmenter.h.

m_acc_jetLink

AE::ConstAccessor<ElementLink<xAOD::JetContainer> > FlavorTagDiscriminants::BTagMuonAugmenter::m_acc_jetLink

private

Definition at line 60 of file BTagMuonAugmenter.h.

m_acc_muon_energyLoss

AE::ConstAccessor<float> FlavorTagDiscriminants::BTagMuonAugmenter::m_acc_muon_energyLoss

private

Definition at line 61 of file BTagMuonAugmenter.h.

m_btag_track_aug

BTagTrackIpAccessor FlavorTagDiscriminants::BTagMuonAugmenter::m_btag_track_aug

private

Definition at line 53 of file BTagMuonAugmenter.h.

m_dec_muon_dR

AE::Decorator<float> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_dR

private

Definition at line 65 of file BTagMuonAugmenter.h.

m_dec_muon_ip3d_d0

AE::Decorator<float> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_ip3d_d0

private

Definition at line 68 of file BTagMuonAugmenter.h.

m_dec_muon_ip3d_d0_significance

AE::Decorator<float> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_ip3d_d0_significance

private

Definition at line 70 of file BTagMuonAugmenter.h.

m_dec_muon_ip3d_sigma_d0

AE::Decorator<float> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_ip3d_sigma_d0

private

Definition at line 72 of file BTagMuonAugmenter.h.

m_dec_muon_ip3d_sigma_z0

AE::Decorator<float> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_ip3d_sigma_z0

private

Definition at line 73 of file BTagMuonAugmenter.h.

m_dec_muon_ip3d_z0

AE::Decorator<float> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_ip3d_z0

private

Definition at line 69 of file BTagMuonAugmenter.h.

m_dec_muon_ip3d_z0_significance

AE::Decorator<float> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_ip3d_z0_significance

private

Definition at line 71 of file BTagMuonAugmenter.h.

m_dec_muon_isDefaults

AE::Decorator<char> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_isDefaults

private

Definition at line 63 of file BTagMuonAugmenter.h.

m_dec_muon_link

AE::Decorator<ElementLink<xAOD::MuonContainer> > FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_link

private

Definition at line 74 of file BTagMuonAugmenter.h.

m_dec_muon_pTrel

AE::Decorator<float> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_pTrel

private

Definition at line 67 of file BTagMuonAugmenter.h.

m_dec_muon_qOverPratio

AE::Decorator<float> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_muon_qOverPratio

private

Definition at line 66 of file BTagMuonAugmenter.h.

m_dec_nAssocMuons

AE::Decorator<int> FlavorTagDiscriminants::BTagMuonAugmenter::m_dec_nAssocMuons

private

Definition at line 64 of file BTagMuonAugmenter.h.

m_flip_config

FlipTagConfig FlavorTagDiscriminants::BTagMuonAugmenter::m_flip_config

private

Definition at line 57 of file BTagMuonAugmenter.h.

m_float_IO

std::vector<CAccDec<float> > FlavorTagDiscriminants::BTagMuonAugmenter::m_float_IO

private

Definition at line 80 of file BTagMuonAugmenter.h.

m_float_IO_variables

std::vector<std::string> FlavorTagDiscriminants::BTagMuonAugmenter::m_float_IO_variables

private

Definition at line 78 of file BTagMuonAugmenter.h.

m_muonAssociationName

std::string FlavorTagDiscriminants::BTagMuonAugmenter::m_muonAssociationName

private

Definition at line 54 of file BTagMuonAugmenter.h.

m_muonMaxDR

float FlavorTagDiscriminants::BTagMuonAugmenter::m_muonMaxDR

private

Definition at line 55 of file BTagMuonAugmenter.h.

m_muonMinpT

float FlavorTagDiscriminants::BTagMuonAugmenter::m_muonMinpT

private

Definition at line 56 of file BTagMuonAugmenter.h.

m_unsigned_char_IO

std::vector<CAccDec<unsigned char> > FlavorTagDiscriminants::BTagMuonAugmenter::m_unsigned_char_IO

private

Definition at line 84 of file BTagMuonAugmenter.h.

m_unsigned_char_IO_variables

std::vector<std::string> FlavorTagDiscriminants::BTagMuonAugmenter::m_unsigned_char_IO_variables

private

Definition at line 83 of file BTagMuonAugmenter.h.

---

The documentation for this class was generated from the following files:

• BTagMuonAugmenter.h
• BTagMuonAugmenter.cxx