SoftMuonObjectCollectionMaker.cxx

Go to the documentation of this file.

/*
   Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
#include "TopSystematicObjectMaker/SoftMuonObjectCollectionMaker.h"
#include "TopConfiguration/TopConfig.h"
#include "TopConfiguration/TreeFilter.h"
#include "TopEvent/EventTools.h"
 
#include "AthContainers/AuxElement.h"
#include "xAODEventInfo/EventInfo.h"
#include "xAODMuon/MuonContainer.h"
#include "xAODMuon/MuonAuxContainer.h"
#include "xAODCore/ShallowCopy.h"
#include "xAODBase/IParticleHelpers.h"
#include "xAODTracking/TrackParticlexAODHelpers.h"
#include "PATInterfaces/SystematicsUtil.h"
 
namespace top {
  SoftMuonObjectCollectionMaker::SoftMuonObjectCollectionMaker(const std::string& name) :
    asg::AsgTool(name),
    m_config(nullptr),
 
    m_specifiedSystematics(),
    m_recommendedSystematics(),
 
    m_calibrationTool("MuonMomentumCalibrationTool"),
    m_muonSelectionToolVeryLooseVeto("MuonSelectionToolVeryLooseVeto"),
    m_softmuonSelectionTool("SoftMuonSelectionTool"){
    declareProperty("config", m_config);
 
    declareProperty("MuonMomentumCalibrationTool", m_calibrationTool);
    declareProperty("MuonSelectionToolVeryLooseVeto", m_muonSelectionToolVeryLooseVeto);
    declareProperty("SoftMuonSelectionTool", m_softmuonSelectionTool);
  }
 
  StatusCode SoftMuonObjectCollectionMaker::initialize() {
    ATH_MSG_INFO(" top::SoftMuonObjectCollectionMaker initialize");
 
    top::check(m_calibrationTool.retrieve(), "Failed to retrieve muon calibration tool");
    top::check(m_muonSelectionToolVeryLooseVeto.retrieve(), "Failed to retrieve Selection Tool");
    top::check(m_softmuonSelectionTool.retrieve(),"Failed to retrieve Selection Tool");
    
    const std:: string& syststr = m_config->systematics();
    std::set<std::string> syst;
 
    if (!m_config->isSystNominal(syststr) && !m_config->isSystAll(syststr)) {
      bool ok = m_config->getSystematicsList(syststr, syst);
      if (!ok) {
        ATH_MSG_ERROR(" top::SoftMuonObjectCollectionMaker could not determine systematic list");
        return StatusCode::FAILURE;
      }
      //here the idea is that if the user specifies AllXXX, we leave syst as an empty string, so that all recommended CP
      // systematics are then used
      if (m_config->contains(syst, "AllMuons")) {
        syst.clear();
      }
      if (m_config->contains(syst, "AllSoftMuons")) {
        syst.clear();
      }
    }
 
    specifiedSystematics(syst);
 
    m_config->systematicsSoftMuons(specifiedSystematics());
 
    ATH_MSG_INFO(" top::SoftMuonObjectCollectionMaker completed initialize");
    return StatusCode::SUCCESS;
  }
 
  StatusCode SoftMuonObjectCollectionMaker::execute(bool executeNominal) {
    const xAOD::EventInfo* eventInfo(nullptr);
 
    top::check(evtStore()->retrieve(eventInfo, m_config->sgKeyEventInfo()), "Failed to retrieve EventInfo");
    const float beam_pos_sigma_x = eventInfo->beamPosSigmaX();
    const float beam_pos_sigma_y = eventInfo->beamPosSigmaY();
    const float beam_pos_sigma_xy = eventInfo->beamPosSigmaXY();
 
    const xAOD::MuonContainer* xaod(nullptr);
 
    top::check(evtStore()->retrieve(xaod, m_config->sgKeyMuons()), "Failed to retrieve Soft Muons");  //we use sgKeyMuons and not sgKeySoftMuons on purpose to use the same collection for muons and soft muons
 
    for (auto systematic : m_specifiedSystematics) {
      if (executeNominal && !m_config->isSystNominal(m_config->systematicName(systematic.hash()))) continue;
      if (!executeNominal && m_config->isSystNominal(m_config->systematicName(systematic.hash()))) continue;
 
      top::check(m_calibrationTool->applySystematicVariation(systematic), "Failed to applySystematicVariation");
 
      std::pair< xAOD::MuonContainer*,
                 xAOD::ShallowAuxContainer* > shallow_xaod_copy = xAOD::shallowCopyContainer(*xaod);
 
      for (xAOD::Muon* muon : *(shallow_xaod_copy.first)) {
        
        if (muon->primaryTrackParticle()) {
          top::check(m_calibrationTool->applyCorrection(*muon), "Failed to applyCorrection");
 
          // don't do the decorations unless the muons are at least Loose
          // this is because it may fail if the muons are at just VeryLoose
          if (m_muonSelectionToolVeryLooseVeto->accept(*muon)||(m_config->softmuonUseLowPt() && m_softmuonSelectionTool->accept(*muon))) {
            double d0sig = xAOD::TrackingHelpers::d0significance(muon->primaryTrackParticle(),
                                                                 beam_pos_sigma_x,
                                                                 beam_pos_sigma_y,
                                                                 beam_pos_sigma_xy);
            muon->auxdecor<float>("d0sig") = d0sig;
 
            if (eventInfo->isAvailable<float>("AnalysisTop_PRIVTX_z_position")) {
              float vtx_z = eventInfo->auxdata<float>("AnalysisTop_PRIVTX_z_position");
              float delta_z0 = muon->primaryTrackParticle()->z0() + muon->primaryTrackParticle()->vz() - vtx_z;
              muon->auxdecor<float>("delta_z0") = delta_z0;
              muon->auxdecor<float>("delta_z0_sintheta") = delta_z0 * std::sin(muon->primaryTrackParticle()->theta());
            }
          }
        }//end of if (muon->primaryTrackParticle())
        
      }//end of loop on muons
 
      bool setLinks = xAOD::setOriginalObjectLink(*xaod, *shallow_xaod_copy.first);
      if (!setLinks) {
        ATH_MSG_ERROR(" Cannot set original object links for soft muons");
        return StatusCode::FAILURE;
      }
 
      std::string outputSGKey = m_config->sgKeySoftMuons(systematic.hash());
      std::string outputSGKeyAux = outputSGKey + "Aux.";
 
      StatusCode save = evtStore()->tds()->record(shallow_xaod_copy.first, outputSGKey);
      StatusCode saveAux = evtStore()->tds()->record(shallow_xaod_copy.second, outputSGKeyAux);
      if (!save || !saveAux) {
        return StatusCode::FAILURE;
      }
    }  // Loop over all systematics
 
    return StatusCode::SUCCESS;
  }
 
  StatusCode SoftMuonObjectCollectionMaker::printout() {
    for (auto systematic : m_specifiedSystematics) {
      const xAOD::MuonContainer* xaod(nullptr);
      top::check(evtStore()->retrieve(xaod, m_config->sgKeySoftMuons(
                                        systematic.hash())), "Failed to retrieve Soft Muons");
 
      ATH_MSG_INFO(" Soft Muons with sgKey = " << m_config->sgKeySoftMuons(systematic.hash()));
      for (auto muon : *xaod) {
        ATH_MSG_INFO("   SOFT MU pT , eta  = " << muon->pt() << " , " << muon->eta());
      }
    }
 
    return StatusCode::SUCCESS;
  }
 
  void SoftMuonObjectCollectionMaker::specifiedSystematics(const std::set<std::string>& specifiedSystematics) {
    const std::vector<CP::SystematicSet> systList = CP::make_systematics_vector(
      m_calibrationTool->recommendedSystematics());
 
    for (const CP::SystematicSet& s : systList) {
      
      if(!m_config->getTreeFilter()->filterTree(s.name())) continue; // Applying tree filter
      m_recommendedSystematics.push_back(s);
      if (s.name() == "") {
        m_specifiedSystematics.push_back(s);
      }
 
      if (m_config->isMC()) {
        if (!m_config->isSystNominal(m_config->systematics())) {
          if (specifiedSystematics.size() == 0) {
            m_specifiedSystematics.push_back(s);
          }
          if (specifiedSystematics.size() > 0) {
            for (auto i : specifiedSystematics) {
              TreeFilter filter(i);
              if (!filter.filterTree(s.name())) {
                m_specifiedSystematics.push_back(s);
              }
            }
          }
        }
      }
    }
    m_recommendedSystematics.sort();
    m_recommendedSystematics.unique();
    m_specifiedSystematics.sort();
    m_specifiedSystematics.unique();
  }
 
}