InDetPhysValMonitoringTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETPHYSVALMONITORING_INDETPHYSVALMONITORINGTOOL_H
#define INDETPHYSVALMONITORING_INDETPHYSVALMONITORINGTOOL_H
 
//local include
#include "TrkTruthTrackInterfaces/IAthSelectionTool.h"
#include "InDetPhysValMonitoring/CutFlow.h"
 
//#include "PATCore/IAsgSelectionTool.h"
#include "AthenaMonitoring/ManagedMonitorToolBase.h"
#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
 
#include "InDetTrackSystematicsTools/InDetTrackTruthOriginTool.h"
#include "InDetTrackSystematicsTools/InDetTrackTruthOriginDefs.h"
 
#include "InDetTruthVertexValidation/IInDetVertexTruthMatchTool.h"
 
#include "InDetRecToolInterfaces/IInDetHardScatterSelectionTool.h"
 
//#gaudi includes
#include "GaudiKernel/ToolHandle.h"
//EDM includes
#include "xAODTruth/TruthParticleContainer.h"
#include "xAODTruth/TruthPileupEventContainer.h"
#include "xAODTruth/TruthEventContainer.h"
#include "xAODEventInfo/EventInfo.h"
#include "xAODJet/JetContainer.h"
 
//Athena
#include "AsgAnalysisInterfaces/IGoodRunsListSelectionTool.h"
#include "AtlasDetDescr/AtlasDetectorID.h"
#include "CxxUtils/checker_macros.h"
#include "InDetIdentifier/PixelID.h"
#include "InDetIdentifier/SCT_ID.h"
#include "InDetIdentifier/TRT_ID.h"
#include "TRT_ReadoutGeometry/TRT_DetectorManager.h"
//STL includes
#include <string>
#include <vector>
 
 
//fwd declaration
class IInDetPhysValDecoratorTool;
class InDetRttPlots;
struct InDetRttPlotConfig; 
namespace IDPVM{
    class CachedGetAssocTruth;
}
 
 
class InDetPhysValMonitoringTool:public ManagedMonitorToolBase{
public:
    InDetPhysValMonitoringTool(const std::string & type, const std::string & name, const IInterface* parent);
    virtual ~InDetPhysValMonitoringTool();
    virtual StatusCode initialize();
    virtual StatusCode bookHistograms();
    virtual StatusCode fillHistograms();
    virtual StatusCode procHistograms();
private:
 
    InDetPhysValMonitoringTool();
    // Private utility methods
    void fillTrackCutFlow(const asg::AcceptData& accept);
    static void fillCutFlow(const asg::AcceptData& accept, std::vector<std::string> & names, std::vector<int> & cutFlow);
    // Get truth particles into a vector, possibly using the pileup from the event
    const std::vector<const xAOD::TruthParticle *> getTruthParticles(const EventContext& ctx) const;
    std::pair<const std::vector<const xAOD::TruthVertex*>, const std::vector<const xAOD::TruthVertex*>> getTruthVertices(const EventContext& ctx) const;
    
    InDetRttPlotConfig getFilledPlotConfig() const;  
 
    int getIndexByEta(const xAOD::TruthParticle& truth) const;
 
    //
    const Trk::TrackParameters* getUnbiasedTrackParameters(const Trk::TrackParameters* trkParameters, const Trk::MeasurementBase* measurement );
    // Do Jet/TIDE plots (Tracking In Dense Environment)
    StatusCode fillHistogramsTrackingInDenseEnvironment(const EventContext& ctx,
                            IDPVM::CachedGetAssocTruth& getAsTruth,
                            const std::vector<const xAOD::TruthParticle*>& truthParticles,
                            const xAOD::TrackParticleContainer& tracks,
                            const xAOD::Vertex* primaryvertex,
                            float beamSpotWeight);
 
    // accessors/decorators
    SG::AuxElement::Accessor<bool>  m_acc_hasTruthFilled{"hasTruthFilled"};
    SG::AuxElement::Decorator<bool> m_dec_hasTruthFilled{"hasTruthFilled"}; 
    SG::AuxElement::Decorator<bool> m_dec_passedTruthSelection{"passedTruthSelection"}; 
    SG::AuxElement::Decorator<bool> m_dec_passedTrackSelection{"passedTrackSelection"}; 
    SG::AuxElement::Accessor<bool>  m_acc_selectedByPileupSwitch{"selectedByPileupSwitch"};
    SG::AuxElement::Decorator<bool> m_dec_selectedByPileupSwitch{"selectedByPileupSwitch"};
 
    // decorate track particle for ntuple writing
    void decorateTrackParticle(const xAOD::TrackParticle & track, const asg::AcceptData & passed) const;
 
    // decorate truth particle for ntuple writing
    void decorateTruthParticle(const xAOD::TruthParticle & truth, const IAthSelectionTool::CutResult & passed) const;
 
    // safely check the "hasTruthFilled" decoration on a truth particle
    bool hasTruthFilled(const xAOD::TruthParticle & truth) const;
    
    // safely check the "selectedByPileupSwitch" decoration on a truth particle
    bool isSelectedByPileupSwitch(const xAOD::TruthParticle & truth) const;
   
    // set the "selectedByPileupSwitch" decoration for all particles in the passed vector
    void markSelectedByPileupSwitch(const std::vector<const xAOD::TruthParticle*> & truthParticles) const;
 
 
    // Jet Selection for CTIDE
    bool passJetCuts(const xAOD::Jet& jet) const;
  
    SG::ReadHandleKey<xAOD::TrackParticleContainer>  m_trkParticleName
        {this,"TrackParticleContainerName", "InDetTrackParticles"};
 
    SG::ReadHandleKey<xAOD::TruthParticleContainer> m_truthParticleName
        {this, "TruthParticleContainerName",  "TruthParticles", ""};
 
    SG::ReadHandleKey<xAOD::VertexContainer>  m_vertexContainerName
        {this,"VertexContainerName", "PrimaryVertices", ""};
 
    SG::ReadHandleKey<xAOD::TruthVertexContainer> m_truthVertexContainerName
        {this,"TruthVertexContainerName",  "TruthVertices",""};
 
    SG::ReadHandleKey<xAOD::EventInfo> m_eventInfoContainerName
        {this,"EventInfoContainerName", "EventInfo", ""};
 
    SG::ReadHandleKey<xAOD::TruthEventContainer> m_truthEventName
        {this, "TruthEvents", "TruthEvents","Name of the truth events container probably either TruthEvent or TruthEvents"};
 
    SG::ReadHandleKey<xAOD::TruthPileupEventContainer> m_truthPileUpEventName
        {this, "TruthPileupEvents", "TruthPileupEvents","Name of the truth pileup events container probably TruthPileupEvent(s)"};
 
    SG::ReadHandleKey<xAOD::JetContainer> m_jetContainerName
        {this, "JetContainerName", "AntiKt4LCTopoJets" , ""};
 
 
    // needed to indicate data dependencies
    std::vector<SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> > m_floatTrkDecor;
    std::vector<SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> > m_intTrkDecor;
    std::vector<SG::ReadDecorHandleKey<xAOD::TruthParticleContainer> > m_floatTruthDecor;
    std::vector<SG::ReadDecorHandleKey<xAOD::TruthParticleContainer> > m_intTruthDecor;
    std::vector<SG::ReadDecorHandleKey<xAOD::JetContainer> > m_intJetDecor;
 
    std::unique_ptr< InDetRttPlots > m_monPlots;
 
 
    BooleanProperty m_useTrackSelection {this, "useTrackSelection", false, "plot only tracks accepted by selection tool"};
    BooleanProperty m_doTruthOriginPlots {this, "doTruthOriginPlots", false, "do plots split by track truth origin"};
    BooleanProperty m_doDuplicatePlots {this, "doDuplicatePlots", false, "Fill duplicate=multi-track per particle plots"};
    BooleanProperty m_doPerAuthorPlots {this, "doPerAuthorPlots", false, "do plots split by track author"};
    BooleanProperty m_doTrackInJetPlots {this, "FillTrackInJetPlots", true, "Fill plots for tracks in jets"}; 
    BooleanProperty m_doHitLevelPlots {this, "doHitLevelPlots", false, "Fill hit efficiency and residual plots"}; 
    BooleanProperty m_doBjetPlots {this, "FillTrackInBJetPlots", false, "Fill plots for tracks in truth-b-tagged jets"}; 
    BooleanProperty m_fillTruthToRecoNtuple {this, "FillTruthToRecoNtuple", false, "Fill an ntuple with truth and matching reco info for more detailed stuidies"}; 
    BooleanProperty m_useVertexTruthMatchTool {this, "useVertexTruthMatchTool", false, "Use the vertex truth matching tool"}; 
    BooleanProperty m_onlyFillMatched {this, "onlyFillTruthMatched", false, "Only fill truth-to-reco (eff, reso, matched hit) plots"};
    BooleanProperty m_doTRTExtensionPlots {this, "doTRTExtensionPlots", true, "do TRT extension plots"};
    BooleanProperty m_useGRL {this, "useGRL", false, "Apply GRL selection or not when running on data"};
    BooleanProperty m_doIDTIDEPlots{this, "doIDTIDEPlots", false, "do ID TIDE derivation plots"};
    BooleanProperty m_fillTechnicalEfficiency{this, "fillTechnicalEfficiency", false, "Fill the technical efficiency plot. Requires additional sihit information in input file"};
    BooleanProperty m_doPRW{this,"doPRW",false,"apply pileup reweight"};
 
    FloatProperty m_maxTrkJetDR{this,"maxTrkJetDR",0.4,"the maximum dR to jets to allow for track-in-jet plots"}; 
    StringProperty m_dirName {this, "DirName", "SquirrelPlots/", "Top level directory to write histograms into"}; 
    StringProperty m_folder {this, "SubFolder", "", "Subfolder to add for plots if desired. Used when working with multiple IDPVM tool instances."}; 
    StringProperty m_pileupSwitch {this, "PileupSwitch", "HardScatter", "Pileup truth strategy to use. May be \"All\", \"HardScatter\", or \"PileUp\""}; 
    FloatProperty m_lowProb{this,"LowProb",0.5,"Truth match prob. cutoff for efficiency (lower bound) and fake (upper bound) classification."}; 
    FloatProperty m_highProb{this,"HighProb",0.8,"Truth match prob. cutoff - currently unused"}; 
    Gaudi::Property<std::vector<double> > m_etaBins{this, "EtaBins", {}};
    Gaudi::Property<std::vector<int> > m_minHits{this, "MinNumberClusters", {}};
 
    Gaudi::Property<float> m_jetAbsEtaMin
    {this, "JetAbsEtaMin", 0.f,
     "Minimum Eta value for jet selection"}; 
    Gaudi::Property<float> m_jetAbsEtaMax
    {this, "JetAbsEtaMax", 2.5f,
     "Maximum Eta value for jet selection"};
    Gaudi::Property<float> m_jetPtMin
    {this, "JetPtMin", 100.0f,
     "Minimum Jet pT for jet selection in GeV"};
    Gaudi::Property<float> m_jetPtMax
    {this, "JetPtMax", 5000.0f,
     "Maximum Jet pT for jet selection in GeV"};
 
  
    ToolHandle<InDet::IInDetTrackSelectionTool> m_trackSelectionTool{this, "TrackSelectionTool", "InDet::InDetTrackSelectionTool/TrackSelectionTool", "Track selection tool to use"};
    ToolHandle<IInDetVertexTruthMatchTool> m_vtxValidTool{this, "VertexTruthMatchTool", "InDetVertexTruthMatchTool/VtxTruthMatchTool", "Vertex truth matching tool to use"};
    ToolHandle<IAthSelectionTool> m_truthSelectionTool{this, "TruthSelectionTool","AthTruthSelectionTool", "Truth selection tool (for efficiencies and resolutions)"};
    ToolHandle<InDet::IInDetTrackTruthOriginTool> m_trackTruthOriginTool{this, "trackTruthOriginTool", "InDet::InDetTrackTruthOriginTool","truth track origin tool"};
    ToolHandle<InDet::IInDetHardScatterSelectionTool> m_hardScatterSelectionTool{this, "hardScatterSelectionTool", "InDet::InDetHardScatterSelectionTool","tool to select the hard scatter reco vertex"};
    ToolHandle<IGoodRunsListSelectionTool> m_grlTool{this, "GoodRunsListSelectionTool", "GoodRunsListSelectionTool/GoodRunsListSelectionTool", "GRL selection tool"};
 
    SG::ReadDecorHandleKey<xAOD::EventInfo> m_weight_pileup_key{this, "PileupWeight_NOSYS", "EventInfo.PileupWeight_NOSYS"};
 
    mutable std::mutex  m_mutex;
    mutable CutFlow     m_truthCutFlow ATLAS_THREAD_SAFE; // Guarded by m_mutex
    std::vector<int> m_prospectsMatched;
    int m_truthCounter = 0;
 
    std::vector<std::string> m_trackCutflowNames;
    std::vector<int> m_trackCutflow;
 
    bool m_usingSpecialPileupSwitch {false};
};
#endif