xAODTestReadJVec.cxx

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration.
 */
 
 
#include "xAODTestReadJVec.h"
#include "StoreGate/ReadHandle.h"
#include "StoreGate/ReadDecorHandle.h"
#include "AthContainers/JaggedVec.h"
#include "AthLinks/ElementLink.h"
#include <format>
#include <print>
#include <sstream>
 
 
namespace {
 

template <class CONT>
std::string formEL (const ElementLink<CONT>& el)
{
  return std::format ("({}:{})",
                      el.dataID(),
                      static_cast<int>(el.index()) == -1 ? "inv" : std::to_string(el.index()));
}
 

template <class T>
std::string form_vec_elt (const T& x)
{
  return std::format ("{}", x);
}
  
 

std::string form_vec_elt (const std::string& x)
{
  return std::format ("'{}'", x);
}
  

template <class CONT>
std::string form_vec_elt (const ElementLink<CONT>& x)
{
  return formEL (x);
}
 

template <class RANGE>
std::string formJVec (const RANGE& r) {
  std::ostringstream ss;
  std::print (ss, "[");
  std::string sep;
  for (const auto & elt : r) {
    std::print (ss, "{}", sep);
    sep = " ";
    std::print (ss, "{}", form_vec_elt (elt));
  }
  std::print (ss, "]");
  return ss.str();
}
 
 
}
 
 
namespace DMTest {
 

StatusCode xAODTestReadJVec::initialize()
{
  ATH_CHECK( m_jvecContainerKey.initialize (SG::AllowEmpty) );
  ATH_CHECK( m_jvecInfoKey.initialize (SG::AllowEmpty) );
  ATH_CHECK( m_jvecDecorKey.initialize (SG::AllowEmpty) );
  ATH_CHECK( m_jvecInfoDecorKey.initialize (SG::AllowEmpty) );
  return StatusCode::SUCCESS;
}
 

StatusCode xAODTestReadJVec::execute (const EventContext& ctx) const
{
  if (!m_jvecContainerKey.empty()) {
    SG::ReadHandle<JVecContainer> jveccont (m_jvecContainerKey, ctx);
    ATH_MSG_INFO( m_jvecContainerKey.key() );
    for (const JVec* jvec : *jveccont) {
      ATH_CHECK( dumpJVec (*jvec) );
      ATH_CHECK( dumpDecor (ctx, *jvec) );
    }
  }
 
  if (!m_jvecInfoKey.empty()) {
    SG::ReadHandle<JVec> jvecinfo (m_jvecInfoKey, ctx);
    ATH_MSG_INFO( m_jvecInfoKey.key() );
    ATH_CHECK( dumpJVec (*jvecinfo) );
    ATH_CHECK( dumpInfoDecor (ctx, *jvecinfo) );
  }
 
  return StatusCode::SUCCESS;
}
 

StatusCode xAODTestReadJVec::dumpJVec (const JVec& jvec) const
{
  ATH_MSG_INFO( "  ivec: {}  fvec: {}  svec: {}  lvec: {}",
                formJVec (jvec.ivec()),
                formJVec (jvec.fvec()),
                formJVec (jvec.svec()),
                formJVec (jvec.lvec()));
  return StatusCode::SUCCESS;
}
 

StatusCode
xAODTestReadJVec::dumpDecor (const EventContext& ctx,
                             const JVec& jvec) const
{
  std::ostringstream ss;
  if (!m_jvecDecorKey.empty()) {
    SG::ReadDecorHandle<JVecContainer, SG::JaggedVecElt<double> > decor (m_jvecDecorKey, ctx);
    std::print (ss, "  decorJVec: {}", formJVec (decor (jvec)));
  }
 
  ATH_MSG_INFO( ss.str() );
  return StatusCode::SUCCESS;
}
 

StatusCode
xAODTestReadJVec::dumpInfoDecor (const EventContext& ctx,
                                 const JVec& jvec) const
{
  std::ostringstream ss;
  if (!m_jvecInfoDecorKey.empty()) {
    SG::ReadDecorHandle<JVec, SG::JaggedVecElt<double> > decor (m_jvecInfoDecorKey, ctx);
    std::print (ss, "  decorJVec: {}", formJVec (decor (jvec)));
  }
  
  ATH_MSG_INFO( ss.str() );
  return StatusCode::SUCCESS;
}
 
 
} // namespace DMTest