DerivationFramework::JetGhostThinning Class Reference

#include <JetGhostThinning.h>

Inheritance diagram for DerivationFramework::JetGhostThinning:

Collaboration diagram for DerivationFramework::JetGhostThinning:

Public Member Functions
	JetGhostThinning (const std::string &t, const std::string &n, const IInterface *p)
virtual	~JetGhostThinning ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	doThinning () const override

Private Attributes
StringProperty	m_streamName
SG::ReadHandleKey< xAOD::JetContainer >	m_jetSGKey
StringProperty	m_selectionString
StringProperty	m_ghostName
StringProperty	m_ghostContainerName
SG::ThinningHandleKey< xAOD::IParticleContainer >	m_ghostContainerKey

Detailed Description

Definition at line 26 of file JetGhostThinning.h.

Constructor & Destructor Documentation

JetGhostThinning()

DerivationFramework::JetGhostThinning::JetGhostThinning	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 15 of file JetGhostThinning.cxx.

    : base_class(t, n, p) {}

~JetGhostThinning()

DerivationFramework::JetGhostThinning::~JetGhostThinning ( )

virtualdefault

Member Function Documentation

doThinning()

StatusCode DerivationFramework::JetGhostThinning::doThinning ( ) const

overridevirtual

Definition at line 70 of file JetGhostThinning.cxx.

                                                                 {
  const EventContext &ctx = Gaudi::Hive::currentContext();
 
  // Retrieve jet collection
  SG::ReadHandle<xAOD::JetContainer> jets(m_jetSGKey, ctx);
  if (!jets.isValid()) {
    ATH_MSG_ERROR("Failed to retrieve jet collection " << m_jetSGKey.key());
    return StatusCode::FAILURE;
  }
 
  // Get the jets that pass the selection
  std::vector<const xAOD::Jet*> selectedJets;
 
  if (!m_selectionString.empty()) {
    // Use the expression parser
    std::vector<int> entries = m_parser->evaluateAsVector();
    if (entries.size() != jets->size()) {
      ATH_MSG_ERROR("Selection string evaluation size mismatch!");
      return StatusCode::FAILURE;
    }
 
    for (size_t i = 0; i < jets->size(); ++i) {
      if (entries[i] == 1) {
        selectedJets.push_back((*jets)[i]);
      }
    }
  } else {
    // Keep all jets
    for (const auto* jet : *jets) {
      selectedJets.push_back(jet);
    }
  }
 
  ATH_MSG_DEBUG("Number of selected jets: " << selectedJets.size()
                << " out of " << jets->size());
 
  // Get thinning handle for the ghost container
  SG::ThinningHandle<xAOD::IParticleContainer> ghostContainer(m_ghostContainerKey, ctx);
 
  if (!ghostContainer.isValid()) {
    ATH_MSG_WARNING("Ghost container " << m_ghostContainerKey.key() << " not valid, skipping");
    return StatusCode::SUCCESS;
  }
 
  size_t nObjects = ghostContainer->size();
  std::vector<bool> mask(nObjects, false);
  const int maskSize = static_cast<int>(mask.size());
 
  // Create accessor for the ghost association
  SG::AuxElement::ConstAccessor<std::vector<ElementLink<xAOD::IParticleContainer>>> ghostAcc(m_ghostName);
 
  size_t nGhostLinks = 0;
 
  // Loop over selected jets and mark ghost objects to keep using their indices
  for (const auto* jet : selectedJets) {
    if (!jet) continue;
 
    // Check if this jet has the ghost association
    if (!ghostAcc.isAvailable(*jet)) {
      ATH_MSG_VERBOSE("Jet does not have ghost association: " << m_ghostName);
      continue;
    }
 
    // Get the ghost links
    const std::vector<ElementLink<xAOD::IParticleContainer>>& ghostLinks = ghostAcc(*jet);
 
    ATH_MSG_VERBOSE("Jet has " << ghostLinks.size() << " ghost objects");
 
    // Mark all valid ghost objects using their indices
    for (const auto& link : ghostLinks) {
      if (!link.isValid()) continue;
 
      int index = link.index();
      if (index < 0) {
        ATH_MSG_VERBOSE("  Ghost link has negative index, skipping");
        continue;
      }
 
      if (index < maskSize) {
        mask[index] = true;
        nGhostLinks++;
        const xAOD::IParticle* ghostObj = *link;
        if (ghostObj) {
          ATH_MSG_VERBOSE("  Ghost object at index " << index << ": pt=" << ghostObj->pt()
                         << ", eta=" << ghostObj->eta());
        }
      }
    }
  }
 
  size_t nKept = std::count(mask.begin(), mask.end(), true);
  ATH_MSG_DEBUG("Found " << nGhostLinks << " ghost links from selected jets");
  ATH_MSG_DEBUG("Ghost container " << m_ghostContainerKey.key() << ": keeping "
               << nKept << " out of " << nObjects << " objects");
 
  ghostContainer.keep(mask);
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode DerivationFramework::JetGhostThinning::finalize ( )

overridevirtual

Definition at line 64 of file JetGhostThinning.cxx.

                                                         {
  ATH_MSG_VERBOSE("finalize() ...");
  return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::JetGhostThinning::initialize ( )

overridevirtual

Definition at line 23 of file JetGhostThinning.cxx.

                                                           {
  ATH_MSG_VERBOSE("initialize() ...");
 
  // Check that we have a jet container
  if (m_jetSGKey.empty()) {
    ATH_MSG_FATAL("No jet collection provided!");
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK(m_jetSGKey.initialize());
  ATH_MSG_INFO("Using " << m_jetSGKey.key() << " as the jet collection");
 
  // Initialize the selection string parser if provided
  if (!m_selectionString.empty()) {
    ATH_CHECK(initializeParser(m_selectionString));
    ATH_MSG_INFO("Jet selection string: " << m_selectionString);
  }
 
  // Check that we have a ghost name
  if (m_ghostName.empty()) {
    ATH_MSG_FATAL("No ghost name provided!");
    return StatusCode::FAILURE;
  }
 
  // Check that we have a ghost container name
  if (m_ghostContainerName.empty()) {
    ATH_MSG_FATAL("No ghost container name provided!");
    return StatusCode::FAILURE;
  }
 
  // Initialize thinning handle key
  m_ghostContainerKey = SG::ThinningHandleKey<xAOD::IParticleContainer>(m_ghostContainerName);
  ATH_CHECK(m_ghostContainerKey.initialize(m_streamName));
 
  ATH_MSG_INFO("Thinning ghost objects:");
  ATH_MSG_INFO("  Ghost name: " << m_ghostName);
  ATH_MSG_INFO("  Ghost container: " << m_ghostContainerName);
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_ghostContainerKey

SG::ThinningHandleKey<xAOD::IParticleContainer> DerivationFramework::JetGhostThinning::m_ghostContainerKey

private

Definition at line 52 of file JetGhostThinning.h.

m_ghostContainerName

StringProperty DerivationFramework::JetGhostThinning::m_ghostContainerName

private

Initial value:

{
      this, "GhostContainerName", "", "Name of the ghost object container (e.g., CaloCalFwdTopoTowers)"}

Definition at line 49 of file JetGhostThinning.h.

m_ghostName

StringProperty DerivationFramework::JetGhostThinning::m_ghostName

private

Initial value:

{
      this, "GhostName", "", "Name of the ghost association (e.g., GhostTower)"}

Definition at line 46 of file JetGhostThinning.h.

m_jetSGKey

SG::ReadHandleKey<xAOD::JetContainer> DerivationFramework::JetGhostThinning::m_jetSGKey

private

Initial value:

{
      this, "JetKey", "", "SG key for jet container"}

Definition at line 40 of file JetGhostThinning.h.

m_selectionString

StringProperty DerivationFramework::JetGhostThinning::m_selectionString

private

Initial value:

{
      this, "SelectionString", "", "Selection string for jets"}

Definition at line 43 of file JetGhostThinning.h.

m_streamName

StringProperty DerivationFramework::JetGhostThinning::m_streamName

private

Initial value:

{this, "StreamName", "",
                              "Name of the stream being thinned"}

Definition at line 37 of file JetGhostThinning.h.

---

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

• JetGhostThinning.h
• JetGhostThinning.cxx