OverlapRemovalGenUseAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ASSOCIATIONUTILS_OVERLAPREMOVALGENUSEALG_H
#define ASSOCIATIONUTILS_OVERLAPREMOVALGENUSEALG_H
 
// Framework includes
#include "AsgTools/ToolHandle.h"
#include "AsgTools/PropertyWrapper.h"
#include "AsgDataHandles/ReadHandleKey.h"
#include "AsgDataHandles/WriteDecorHandleKeyArray.h"
#include "AsgDataHandles/ReadDecorHandleKeyArray.h"
 
#include "AnaAlgorithm/AnaAlgorithm.h"
 
// EDM includes
#include "xAODBase/IParticleContainer.h"
 
// Local includes
#include "AssociationUtils/IOverlapRemovalTool.h"

class OverlapRemovalGenUseAlg : public EL::AnaAlgorithm
{
 
  public:

    OverlapRemovalGenUseAlg(const std::string& name, ISvcLocator* svcLoc);

    virtual StatusCode initialize();

    virtual StatusCode execute();
 
  private:

    template<class ContainerType>
    void applySelection(const ContainerType& container);
 
    // Reset decorations to failing
    template<class ContainerType>
    void setDefaultDecorations(const ContainerType& container);

    template<class ObjType>
    bool selectObject(const ObjType& obj);

    void printObjects(const xAOD::IParticleContainer& container,
                      const std::string& type);

    ToolHandle<ORUtils::IOverlapRemovalTool> m_orTool{this, "OverlapRemovalTool", ""};
   
    template <class ContainerType> class DataKeyHandler {
      public:
       DataKeyHandler(EL::AnaAlgorithm* owner,
                      const std::string& propName,
                      const std::string& defaultValue,
                      const std::string& descrip):
                        m_readKey{owner,propName, defaultValue, descrip},
                        m_readDecorKeys{owner, propName + "ReadDecors", {}, "External input data dependencies for "+propName},
                        m_writeDecorKeys{owner,propName + "WriteDecors", {}, "Dependencies written for "+propName}{}
       StatusCode initialize(bool allow_empty = false){
         if (!m_readKey.initialize(!allow_empty).isSuccess()) return StatusCode::FAILURE;
         if (!m_readDecorKeys.initialize().isSuccess()) return StatusCode::FAILURE;
         if (!m_writeDecorKeys.initialize().isSuccess()) return StatusCode::FAILURE;
         return StatusCode::SUCCESS;
       }
       operator const SG::ReadHandleKey<ContainerType>& () const  {return m_readKey;}
       const SG::ReadHandleKey<ContainerType>& hk() const  {return m_readKey;}
       std::string key() const { return m_readKey.key();}
       bool empty() const { return m_readKey.empty(); }
       void declareDependency(const std::string& variable) { if (!empty() && !variable.empty()) m_readDecorKeys.emplace_back(m_readKey.key() + "." + variable );}
       void declareOutput(const std::string& variable) { if (!empty() && !variable.empty()) m_writeDecorKeys.emplace_back(m_readKey.key() + "." + variable); }
 
       template <class T>
       void lockDecor (const std::string& decorKey, const EventContext& ctx) const {
         for (const SG::WriteDecorHandleKey<ContainerType>& dhk : m_writeDecorKeys) {
           if (SG::decorKeyFromKey (dhk.key()) == decorKey) {
             SG::WriteDecorHandle<ContainerType, T> h (dhk, ctx);
             if (h->size() > 0)
               (void)h.getDecorationArray();
           }
         }
       }
     private:
       SG::ReadHandleKey<ContainerType> m_readKey{};
       SG::ReadDecorHandleKeyArray<ContainerType> m_readDecorKeys{};
       SG::WriteDecorHandleKeyArray<ContainerType> m_writeDecorKeys{};
    };
    
    DataKeyHandler<xAOD::JetContainer> m_jetKey{this, "JetKey", "AntiKt4EMPFlowJets",
                                                    "StoreGate/TEvent key for jets"};
 
    DataKeyHandler<xAOD::ElectronContainer> m_electronKey{this, "ElectronKey", "Electrons",
                                                    "StoreGate/TEvent key for electrons"};
    
    DataKeyHandler<xAOD::PhotonContainer> m_photonKey{this, "PhotonKey", "Photons",
                                                    "StoreGate/TEvent key for photons"};
    
    DataKeyHandler<xAOD::MuonContainer> m_muonKey{this, "MuonKey", "Muons",
                                            "StoreGate/TEvent key for muons"};
 
    DataKeyHandler<xAOD::TauJetContainer> m_tauKey{this, "TauKey", "TauJets",
                                            "StoreGate/TEvent key for taus"};
    
    SG::ReadHandleKey<xAOD::VertexContainer> m_vtxKey{this, "VertexKey", "PrimaryVertices",
                                             "StoreGate/TEvent key for the vertex container"};
    
    Gaudi::Property<std::string> m_bJetLabel{this, "BJetLabel", "", "Input label for b-tagged jets"};
    Gaudi::Property<std::string> m_electronLabel{this, "ElectronLabel", "DFCommonElectronsLHLoose",
                                                 "Input label for passing electrons"};
    Gaudi::Property<std::string> m_photonLabel{this, "PhotonLabel", "DFCommonPhotonsIsEMLoose",
                                                 "Input label for passing photons"};
    Gaudi::Property<std::string> m_muonLabel{this, "MuonLabel", "DFCommonMuonPassIDCuts",
                                             "Input label for passing muons"};
    Gaudi::Property<std::string> m_tauLabel{this, "TauLabel", "DFCommonTausLoose",
                                          "Input label for passing taus" };
    
    Gaudi::Property<std::string> m_selectionLabel{this, "SelectionLabel", "selected", 
                                "Input label for the OverlapRemovalTool"};
                                
    Gaudi::Property<std::string> m_overlapLabel{this, "OverlapLabel", "overlaps",
                                                "Output label for the OverlapRemovalTool"};
    
    Gaudi::Property<bool> m_defaultValue{this, "DefaultValue", true,  "Default value for objects failing OR"};
    Gaudi::Property<float> m_ptCut{this, "PtCut", 20., "Minimum pt for consideration"};
    Gaudi::Property<float> m_etaCut{this, "EtaCut", 4.5, "Maximum eta for consideration"};
 
};
 
#endif