AsgViewFromSelectionAlg.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/

 
 
 
//
// includes
//
 
#include <AsgAnalysisAlgorithms/AsgViewFromSelectionAlg.h>
 
#include <CxxUtils/fpcompare.h>
#include <AthContainers/ConstDataVector.h>
#include <xAODCore/AuxContainerBase.h>
#include <xAODEgamma/PhotonContainer.h>
#include <xAODEgamma/ElectronContainer.h>
#include <xAODJet/JetContainer.h>
#include <xAODMuon/MuonContainer.h>
#include <xAODTau/TauJetContainer.h>
#include <xAODTau/DiTauJetContainer.h>
#include <xAODTracking/TrackParticleContainer.h>
#include <xAODTruth/TruthParticleContainer.h>
 
//
// method implementations
//
 
namespace CP
{
  template<typename Type> StatusCode AsgViewFromSelectionAlg ::
  executeTemplate (const CP::SystematicSet& sys)
  {
    const Type *input = nullptr;
    ANA_CHECK (evtStore()->retrieve (input, m_inputHandle.getName (sys)));
    auto viewCopy = std::make_unique<ConstDataVector<Type>> (SG::VIEW_ELEMENTS);
    for (const auto particle : *input)
    {
      bool keep = true;
      for (const auto& accessor : m_accessors)
      {
        if ((accessor.first->getBits (*particle) | accessor.second) != selectionAccept())
        {
          keep = false;
          break;
        }
      }
      if (keep)
      {
        viewCopy->push_back (particle);
      }
    }
 
    if (m_sortPt)
    {
      std::sort (viewCopy->begin(), viewCopy->end(), [] (const xAOD::IParticle *a, const xAOD::IParticle *b) {return CxxUtils::fpcompare::greater (a->pt(), b->pt());});
    }
 
    // If anyone might be concerned about efficiency here, this will
    // add/sort a couple more entries than needed only to remove them
    // from the vector afterwards, so there is a slight efficiency
    // loss.  However, this option is not expected to be used very
    // often and the algorithm is still expected to run quickly, so I
    // decided to keep the code above simpler and just do this as a
    // separate step, instead of trying to optimize this by
    // integrating it with the code above.
    if (viewCopy->size() > m_sizeLimit)
      viewCopy->resize (m_sizeLimit);
 
    // In case we want to output a view copy, do that here.
    if (!m_deepCopy)
    {
      ANA_CHECK (evtStore()->record (viewCopy.release(),
                                     m_outputHandle.getName (sys)));
      return StatusCode::SUCCESS;
    }
 
    // Apparently we want to make a deep copy. So set that one up.
    auto deepCopy = std::make_unique<Type> ();
    auto aux = std::make_unique<xAOD::AuxContainerBase> ();
    deepCopy->setStore (aux.get());
    deepCopy->reserve (viewCopy->size());
    for (auto particle : *viewCopy)
    {
      auto pcopy = std::make_unique<typename Type::base_value_type> ();
      typename Type::value_type pcopyPtr = pcopy.get();
      deepCopy->push_back (std::move (pcopy));
      *pcopyPtr = *particle;
    }
 
    // Record the deep copy into the event store.
    ANA_CHECK (evtStore()->record (deepCopy.release(),
                                   m_outputHandle.getName (sys)));
    ANA_CHECK (evtStore()->record (aux.release(),
                                   m_outputHandle.getName (sys) + "Aux."));
 
    return StatusCode::SUCCESS;
  }
 
 
 
 
  StatusCode AsgViewFromSelectionAlg ::
  executeFindType (const CP::SystematicSet& sys)
  {
    if( m_allowMissing ) {
      const std::string& name = m_inputHandle.getName( sys );
      if( ! evtStore()->contains< xAOD::IParticleContainer >( name ) ) {
        m_function = &AsgViewFromSelectionAlg::executeMissing;
        return StatusCode::SUCCESS;
      }
    }
 
    const xAOD::IParticleContainer *input = nullptr;
    ANA_CHECK (m_inputHandle.retrieve (input, sys));
 
    if (dynamic_cast<const xAOD::ElectronContainer*> (input))
    {
      m_function =
        &AsgViewFromSelectionAlg::executeTemplate<xAOD::ElectronContainer>;
    }
    else if (dynamic_cast<const xAOD::PhotonContainer*> (input))
    {
      m_function =
        &AsgViewFromSelectionAlg::executeTemplate<xAOD::PhotonContainer>;
    }
    else if (dynamic_cast<const xAOD::JetContainer*> (input))
    {
      m_function =
        &AsgViewFromSelectionAlg::executeTemplate<xAOD::JetContainer>;
    }
    else if (dynamic_cast<const xAOD::MuonContainer*> (input)) {
      m_function =
        &AsgViewFromSelectionAlg::executeTemplate<xAOD::MuonContainer>;
    }
    else if (dynamic_cast<const xAOD::TauJetContainer*> (input))
    {
      m_function =
        &AsgViewFromSelectionAlg::executeTemplate<xAOD::TauJetContainer>;
    }
    else if (dynamic_cast<const xAOD::DiTauJetContainer*> (input))
    {
      m_function =
        &AsgViewFromSelectionAlg::executeTemplate<xAOD::DiTauJetContainer>;
    }
    else if (dynamic_cast<const xAOD::TrackParticleContainer*> (input))
    {
      m_function =
        &AsgViewFromSelectionAlg::executeTemplate<xAOD::TrackParticleContainer>;
    }
    else if (dynamic_cast<const xAOD::TruthParticleContainer*> (input))
    {
      m_function =
        &AsgViewFromSelectionAlg::executeTemplate<xAOD::TruthParticleContainer>;
    }
    else
    {
      ANA_MSG_ERROR ("unknown type contained in AsgViewFromSelectionAlg, please extend it");
      return StatusCode::FAILURE;
    }
 
    return (this->*m_function) (sys);
  }
 
 
 
  StatusCode AsgViewFromSelectionAlg ::
  executeMissing (const CP::SystematicSet&)
  {
    return StatusCode::SUCCESS;
  }
 
 
 
 
  StatusCode AsgViewFromSelectionAlg ::
  initialize ()
  {
    ANA_CHECK (m_systematicsList.service().registerCopy (m_inputHandle.getNamePattern(), m_outputHandle.getNamePattern()));
    ANA_CHECK (m_inputHandle.initialize (m_systematicsList));
    ANA_CHECK (m_outputHandle.initialize (m_systematicsList));
    ANA_CHECK (m_systematicsList.initialize());
 
    if (m_ignore.size() > m_selection.size())
    {
      ANA_MSG_ERROR ("ignore property can't have more properties than selection property");
      return StatusCode::FAILURE;
    }
    for (std::size_t iter = 0, end = m_selection.size(); iter != end; ++ iter)
    {
      SelectionType ignore = 0;
      if (iter < m_ignore.size())
        ignore = m_ignore[iter];
      std::unique_ptr<ISelectionReadAccessor> accessor;
      ANA_CHECK (makeSelectionReadAccessor (m_selection[iter], accessor));
      m_accessors.push_back (std::make_pair (std::move (accessor), ignore));
    }
 
#ifndef XAOD_STANDALONE
    const CLID clidRead = detail::getClidForDependency<xAOD::IParticleContainer>("", "deco", false);
    const CLID clidWrite = detail::getClidForDependency<xAOD::IParticleContainer>("", "deco", true);
    std::function<void(const DataObjID&, Gaudi::DataHandle::Mode)> addAlgDependency = [this] (const DataObjID& id, Gaudi::DataHandle::Mode mode) {
      this->addDependency(id, mode);
    };
    for (const auto& decoName : m_systematicsList.service().getObjectDecorations(m_inputHandle.getNamePattern()))
    {
      ANA_CHECK (detail::addSysDependency(msg(), m_systematicsList.service(), addAlgDependency, clidRead, m_inputHandle.getNamePattern(), Gaudi::DataHandle::Reader, decoName, false));
      ANA_CHECK (detail::addSysDependency(msg(), m_systematicsList.service(), addAlgDependency, clidWrite, m_outputHandle.getNamePattern(), Gaudi::DataHandle::Writer, decoName, true));
    }
#endif
 
    return StatusCode::SUCCESS;
  }
 
 
 
  StatusCode AsgViewFromSelectionAlg ::
  execute (const EventContext& /*ctx*/)
  {
    for (const auto& sys : m_systematicsList.systematicsVector())
    {
      ANA_CHECK ((this->*m_function) (sys));
    }
    return StatusCode::SUCCESS;
  }
}