DecoratorAlg.icc

Go to the documentation of this file.

// In case the extension is confusing, this is a -*- C++ -*- file
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "StoreGate/ReadDecorHandle.h"
 
#include <exception>
 
namespace FlavorTagInference {
  template <typename C, typename D, typename N>
  StatusCode DecoratorAlg<C,D,N>::initialize()
  {
    return initializeInternal();
  }
 
  template <typename C, typename D, typename N>
  StatusCode DecoratorAlg<C,D,N>::initializeInternal(
    DecoratorAlg::ExtraDependencies extraDeps)
  {
    ATH_CHECK(m_containerKey.initialize());
    ATH_CHECK(m_constituentKey.initialize(!m_constituentKey.empty()));
    ATH_CHECK(m_electronKey.initialize(!m_electronKey.empty()));
    ATH_CHECK(m_muonKey.initialize(!m_muonKey.empty()));
 
    ATH_CHECK(m_decorator.retrieve());
 
    std::set<std::string> veto(
      m_undeclaredReadDecorKeys.begin(),
      m_undeclaredReadDecorKeys.end());
 
    // now we build data dependencies from the internal tools. We have
    // to reserve the vectors here to prevent a segfault since read /
    // write handles aren't movable once declaired as a property.
    auto deps = m_decorator->getDependencies();
    // jet inputs
    auto auxKeys = deps.bTagInputs;
    auxKeys.merge(extraDeps);
    m_aux.reserve(auxKeys.size());
    for (const std::string& key: auxKeys) {
      const std::string full = m_containerKey.key() + "." + key;
      if (veto.count(full)) {
        ATH_MSG_DEBUG("Not declaring accessor: " + full);
        continue;
      }
      ATH_MSG_DEBUG("Adding accessor: " + full);
      m_aux.emplace_back(this, key, full, "");
      ATH_CHECK(m_aux.back().initialize());
    }
    // track inputs
    auto trackInputs = deps.trackInputs;
    if (!trackInputs.empty() && m_constituentKey.empty()) {
      ATH_MSG_ERROR("using track inputs without defining the input container");
      return StatusCode::FAILURE;
    }
    m_constituentAux.reserve(trackInputs.size());
    for (const std::string& key: trackInputs) {
      const std::string full = m_constituentKey.key() + "." + key;
      if (veto.count(full)) {
        ATH_MSG_DEBUG("Not declaring accessor: " + full);
        continue;
      }
      ATH_MSG_DEBUG("Adding constituent accessor: " + full);
      m_constituentAux.emplace_back(this, key, full, "");
      ATH_CHECK(m_constituentAux.back().initialize());
    }
    // electron inputs
    size_t n_electron_inputs = deps.electronInputs.size();
    if (n_electron_inputs > 0 && m_electronKey.empty()) {
      ATH_MSG_ERROR("using electrons without defining the input container");
      return StatusCode::FAILURE;
    }
    m_electronAux.reserve(n_electron_inputs);
    for (const std::string& key: deps.electronInputs) {
      const std::string full = m_electronKey.key() + "." + key;
      ATH_MSG_DEBUG("Adding electron accessor: " + full);
      m_electronAux.emplace_back(this, key, full, "");
      ATH_CHECK(m_electronAux.back().initialize());
    }
    // muon inputs
    size_t n_muon_inputs = deps.muonInputs.size();
    if (n_muon_inputs > 0 && m_muonKey.empty()) {
      ATH_MSG_ERROR("using muons without defining the input container");
      return StatusCode::FAILURE;
    }
    m_muonAux.reserve(n_muon_inputs);
    for (const std::string& key: deps.muonInputs) {
      const std::string full = m_muonKey.key() + "." + key;
      ATH_MSG_DEBUG("Adding muon accessor: " + full);
      m_muonAux.emplace_back(this, key, full, "");
      ATH_CHECK(m_muonAux.back().initialize());
    }
    // jet outputs
    std::set<std::string> keys = deps.bTagOutputs;
    m_decor.reserve(keys.size());
    for (const std::string& key: keys) {
      const std::string full = m_containerKey.key() + "." + key;
      m_decor.emplace_back(this, key, full, "");
      ATH_CHECK(m_decor.back().initialize());
      // look up auxids
      SG::auxid_t auxid = SG::AuxTypeRegistry::instance().findAuxID(key);
      ATH_MSG_DEBUG("Added decorator: " + full + ","
                    " key " + key + " has auxid " + std::to_string(auxid) );
      m_auxids.push_back(auxid);
    }
    ATH_MSG_DEBUG("Finished setting up");
    return StatusCode::SUCCESS;
  }
 
 
  template <typename C, typename D, typename N>
  StatusCode DecoratorAlg<C,D,N>::execute(const EventContext& cxt ) const {
    SG::ReadHandle<C> container(
      m_containerKey, cxt);
    if (!container.isValid()) {
      ATH_MSG_ERROR("no container " << container.key());
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG(
      "Decorating " + std::to_string(container->size()) + " elements");
    for (const auto* element: *container) {
      m_decorator->decorate(*element);
    }
 
    // Lock the decorations
    //
    for (SG::auxid_t id: m_auxids) {
      ATH_MSG_DEBUG("locking auxid " << id << " in " << m_containerKey.key());
      const_cast<C*>(container.cptr())->lockDecoration(id);
    }
 
    ATH_MSG_DEBUG("Finished decorating");
    
    return StatusCode::SUCCESS;
  }
 
  template <typename C, typename D, typename N>
  StatusCode DecoratorAlg<C,D,N>::finalize() {
    return StatusCode::SUCCESS;
  }
 
}