TopObjectSelection.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
// $Id: TopObjectSelection.h 810745 2017-09-29 14:03:01Z iconnell $
#ifndef ANALYSISTOP_TOPOBJECTSELECTONTOOLS_TOPOBJECTSELECTION_H
#define ANALYSISTOP_TOPOBJECTSELECTONTOOLS_TOPOBJECTSELECTION_H
 
// system include(s):
#include <memory>
#include <vector>
 
// Framework include(s):
#include "AsgTools/AsgTool.h"
#include "AsgTools/ToolHandle.h"
#include "AsgTools/ToolHandleArray.h"
#include "AsgTools/AnaToolHandle.h"
#include "AssociationUtils/IOverlapRemovalTool.h"
 
// Top include(s):
#include "TopObjectSelectionTools/ElectronSelectionBase.h"
#include "TopObjectSelectionTools/FwdElectronSelectionBase.h"
#include "TopObjectSelectionTools/MuonSelectionBase.h"
#include "TopObjectSelectionTools/SoftMuonSelectionBase.h"
#include "TopObjectSelectionTools/JetSelectionBase.h"
#include "TopObjectSelectionTools/JetGhostTrackSelectionBase.h"
#include "TopObjectSelectionTools/TauSelectionBase.h"
#include "TopObjectSelectionTools/PhotonSelectionBase.h"
#include "TopObjectSelectionTools/TrackSelectionBase.h"
#include "TopObjectSelectionTools/OverlapRemovalBase.h"
#include "TopSystematicObjectMaker/ElectronInJetSubtractionCollectionMaker.h"
 
// boosted-tagging includes
 
// b-tagging
#include "FTagAnalysisInterfaces/IBTaggingSelectionTool.h"
#include "TopEvent/Event.h"
 
#include "xAODMuon/MuonContainer.h"
#include "xAODJet/JetContainer.h"
 
// forward declare
namespace xAOD {
  class SystematicEvent;
}
 
namespace top {
  class TopConfig;
 
  class TopObjectSelection: public asg::AsgTool {
  public:
    explicit TopObjectSelection(const std::string& name);
    virtual ~TopObjectSelection() {}
 
    // Delete Standard constructors
    TopObjectSelection(const TopObjectSelection& rhs) = delete;
    TopObjectSelection(TopObjectSelection&& rhs) = delete;
    TopObjectSelection& operator = (const TopObjectSelection& rhs) = delete;
 
    StatusCode initialize();
 
    StatusCode execute(bool);
 
    void electronSelection(ElectronSelectionBase* ptr);
 
 
    void fwdElectronSelection(FwdElectronSelectionBase* ptr);
 
    void muonSelection(MuonSelectionBase* ptr);
 
    void softmuonSelection(SoftMuonSelectionBase* ptr);
 
    void tauSelection(TauSelectionBase* ptr);
 
    void jetSelection(JetSelectionBase* ptr);
 
    void photonSelection(PhotonSelectionBase* ptr);
 
 
    void largeJetSelection(JetSelectionBase* ptr);
 
    void trackJetSelection(JetSelectionBase* ptr);
    
    void jetGhostTrackSelection(JetGhostTrackSelectionBase* ptr);
 
    void trackSelection(TrackSelectionBase* ptr);
 
 
    void overlapRemovalPostSelection(OverlapRemovalBase* ptr);
    void overlapRemovalPostSelectionTrackJets(OverlapRemovalBase* ptr);
 
    virtual void print(MsgStream& os) const;
 
    virtual void print() const;
  private:
    void applySelectionPreOverlapRemoval();
    void applySelectionPreOverlapRemovalPhotons();
    void applySelectionPreOverlapRemovalElectrons();
    void applySelectionPreOverlapRemovalFwdElectrons();
    void applySelectionPreOverlapRemovalMuons();
    void applySelectionPreOverlapRemovalSoftMuons();
    void applySelectionPreOverlapRemovalTaus();
    void applySelectionPreOverlapRemovalJets();
    void applySelectionPreOverlapRemovalLargeRJets();
    void applySelectionPreOverlapRemovalTrackJets();
    void applySelectionPreOverlapRemovalJetGhostTracks();
    void applySelectionPreOverlapRemovalTracks();
 
    virtual StatusCode applyOverlapRemoval();
    virtual StatusCode applyOverlapRemoval(const bool isLoose, const std::string& sgKey);
    virtual StatusCode applyOverlapRemoval(xAOD::SystematicEvent* currentSystematic);
 
    void applyTightSelectionPostOverlapRemoval(const xAOD::IParticleContainer* xaod,
                                               std::vector<unsigned int>& indices);
    void trackJetOverlapRemoval(const xAOD::IParticleContainer* xaod_el,
                                const xAOD::IParticleContainer* xaod_mu,
                                const xAOD::IParticleContainer* xaod_tjet,
                                std::vector<unsigned int>& goodElectrons,
                                std::vector<unsigned int>& goodMuons,
                                std::vector<unsigned int>& goodTrackJets);
                                         
    void decorateSoftMuonsPostOverlapRemoval(const xAOD::MuonContainer* xaod_softmu,
                                         std::vector<unsigned int>& goodMuons);
 
    std::shared_ptr<top::TopConfig> m_config;
 
    std::unique_ptr<top::ElectronSelectionBase> m_electronSelection;
 
    std::unique_ptr<top::FwdElectronSelectionBase> m_fwdElectronSelection;
 
    std::unique_ptr<top::MuonSelectionBase> m_muonSelection;
 
    std::unique_ptr<top::SoftMuonSelectionBase> m_softmuonSelection;
 
    std::unique_ptr<top::TauSelectionBase> m_tauSelection;
 
    std::unique_ptr<top::JetSelectionBase> m_jetSelection;
 
    std::unique_ptr<top::PhotonSelectionBase> m_photonSelection;
 
 
    std::unique_ptr<top::JetSelectionBase> m_largeJetSelection;
 
    std::unique_ptr<top::JetSelectionBase> m_trackJetSelection;
    
    std::unique_ptr<top::JetGhostTrackSelectionBase> m_jetGhostTrackSelection;
 
    std::unique_ptr<top::TrackSelectionBase> m_trackSelection;
 
    std::unique_ptr<top::OverlapRemovalBase> m_overlapRemovalToolPostSelection;
 
    //Electron In Jet Subtraction
    std::unique_ptr<top::ElectronInJetSubtractionCollectionMaker> m_electronInJetSubtractor;
 
    // Pass selection strings
    const std::string m_passPreORSelection;
    const std::string m_passPreORSelectionLoose;
    // the following two are used to give failing JVT and failing fJVT jets a lower priority in the OR
    const std::string m_ORToolDecoration;
    const std::string m_ORToolDecorationLoose;
 
    // Do we need to request loose lepton selection
    bool m_doLooseCuts;
 
    // do decorate the jets with the b-tagging flags
    std::unordered_map<std::string, ToolHandle<IBTaggingSelectionTool> > m_btagSelTools;
    std::unordered_map<std::string, ToolHandle<IBTaggingSelectionTool> > m_trkjet_btagSelTools;
    
    // Boolean to handle only running selection on nominal/systematics
    bool m_executeNominal;
    
    //helper OR tool for soft muons
    asg::AnaToolHandle<ORUtils::IOverlapRemovalTool> m_overlapRemovalTool_softMuons_Alljets;
 
    // Function to decorate event info
    void decorateEventInfoPostOverlapRemoval(int, bool);
    float calculateMinDRMuonJet(const xAOD::Muon& mu, const xAOD::JetContainer* xaod_jet, std::vector<unsigned int>& goodJets, bool useRapidity=false);
  };
}
#endif