TauObjectCollectionMaker.cxx

Go to the documentation of this file.

/*
   Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
// $Id: TauObjectCollectionMaker.cxx  $
#include "TopSystematicObjectMaker/TauObjectCollectionMaker.h"
#include "TopConfiguration/TopConfig.h"
#include "TopConfiguration/TreeFilter.h"
#include "TopEvent/EventTools.h"
 
#include "xAODTau/TauJetContainer.h"
#include "xAODTau/TauJetAuxContainer.h"
#include "xAODCore/ShallowCopy.h"
#include "xAODBase/IParticleHelpers.h"
#include "PATInterfaces/SystematicsUtil.h"
 
namespace top {
  TauObjectCollectionMaker::TauObjectCollectionMaker(const std::string& name) :
    asg::AsgTool(name),
    m_config(nullptr),
 
    m_specifiedSystematics(),
    m_recommendedSystematics(),
 
    m_calibrationTool("TauSmearingTool"),
    m_truthMatchingTool("TauAnalysisTools::TauTruthMatchingTool") {
    declareProperty("config", m_config);
 
    declareProperty("TauSmearingTool", m_calibrationTool);
  }
 
  StatusCode TauObjectCollectionMaker::initialize() {
    ATH_MSG_INFO(" top::TauObjectCollectionMaker initialize");
 
    top::check(m_calibrationTool.retrieve(), "Failed to retrieve tau calibration tool");
    if (m_config->isMC())
      top::check(m_truthMatchingTool.retrieve(), "Failed to retrieve tau truth matching 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::TauObjectCollectionMaker 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, "AllTaus")) {
        syst.clear();
      }
    }
 
    specifiedSystematics(syst);
 
    m_config->systematicsTaus(specifiedSystematics());
 
    return StatusCode::SUCCESS;
  }
 
  StatusCode TauObjectCollectionMaker::execute(bool executeNominal) {
    const xAOD::TauJetContainer* xaod(nullptr);
 
    top::check(evtStore()->retrieve(xaod, m_config->sgKeyTaus()), "Failed to retrieve Taus");
 
    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::TauJetContainer*, xAOD::ShallowAuxContainer* > shallow_xaod_copy = xAOD::shallowCopyContainer(
        *xaod);
 
      for (auto tau : *(shallow_xaod_copy.first)) {
        if (m_config->isMC())
          m_truthMatchingTool->getTruth(*tau);
 
        top::check(m_calibrationTool->applyCorrection(*tau), "Failed to applyCorrection");
      }
 
 
      bool setLinks = xAOD::setOriginalObjectLink(*xaod, *shallow_xaod_copy.first);
      if (!setLinks) ATH_MSG_ERROR(" Cannot set original object links for taus, MET recalculation may struggle");
 
      // Save corrected xAOD Container to StoreGate / TStore
      std::string outputSGKey = m_config->sgKeyTaus(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 TauObjectCollectionMaker::printout() {
    for (auto s : m_specifiedSystematics) {
      const xAOD::TauJetContainer* xaod(nullptr);
      top::check(evtStore()->retrieve(xaod, m_config->sgKeyTaus(s.hash())), "Failed to retrieve Taus");
 
      ATH_MSG_INFO(" Taus with sgKey = " << m_config->sgKeyTaus(s.hash()));
      for (auto x : *xaod) {
        ATH_MSG_INFO("   TAU pT , eta  = " << x->pt() << " , " << x->eta());
      }
    }
 
    return StatusCode::SUCCESS;
  }
 
  void TauObjectCollectionMaker::specifiedSystematics(const std::set<std::string>& specifiedSystematics) {
    const std::vector<CP::SystematicSet> systList = CP::make_systematics_vector(
      m_calibrationTool->recommendedSystematics());
 
    for (auto 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();
  }
}