InDetRttPlots.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETPHYSVALMONITORING_INDETRTTPLOTS
#define INDETPHYSVALMONITORING_INDETRTTPLOTS
 
// std includes
#include <string>
#include <memory>
 
// local includes
#include "InDetPlotBase.h"
#include "InDetBasicPlot.h"
 
#include "TrkValHistUtils/RecoInfoPlots.h"
#include "TrkValHistUtils/TruthInfoPlots.h"
#include "InDetPerfPlot_nTracks.h"
#include "InDetPerfPlot_FakeRate.h"
#include "InDetPerfPlot_Efficiency.h"
#include "InDetPerfPlot_HitResidual.h"
#include "InDetPerfPlot_HitEfficiency.h"
#include "InDetPerfPlot_TrackParameters.h"
#include "TrkValHistUtils/IDHitPlots.h"
#include "InDetPerfPlot_Hits.h"
#include "InDetPerfPlot_Vertex.h"
#include "InDetPerfPlot_VertexTruthMatching.h"
#include "InDetPerfPlot_VerticesVsMu.h"
#include "InDetPerfPlot_TrkInJet.h"
#include "InDetPerfPlot_TRTExtension.h"
#include "InDetPerfPlot_Duplicate.h"
 
#include "xAODTracking/TrackParticle.h"
#include "xAODTracking/Vertex.h"
#include "xAODTracking/VertexContainer.h"
#include "xAODEventInfo/EventInfo.h"
 
#include "InDetPerfPlot_Resolution.h"
#include "InDetPerfNtuple_TruthToReco.h" 
 
#include "InDetTrackSystematicsTools/InDetTrackTruthOriginDefs.h"
 
 
struct InDetRttPlotConfig{
  bool isITk{false};
 
  bool doTrackParameters{true}; 
  bool doNTracks{true}; 
  bool doHitResidualPlot{false}; 
  bool doHitEffPlot{false}; 
  bool doHitsRecoTracksPlots{true}; 
  bool doTrtExtensionPlots{true}; 
 
  bool doFakePlots{true}; 
  bool doMissingTruthFakePlots{true}; 
  bool doHitsFakeTracksPlots{true};
  bool doHitsUnlinkedTracksPlots{true};
 
  bool doEffPlots{true};
  bool doDuplicatePlots{false};
  bool doTechEffPlots{false};
 
  bool doResolutionPlotPrim{true}; 
  bool doResolutionPlotPrim_truthFromB{false}; 
  bool doResolutionPlotSecd{false};
  bool doHitsMatchedTracksPlots{true};
 
  bool doVertexPlots{true}; 
  bool doVerticesVsMuPlots{true}; 
  bool doHardScatterVertexPlots{true}; 
 
  bool doVertexTruthMatchingPlots{true};
  bool doHardScatterVertexTruthMatchingPlots{true}; 
 
  bool doTrkInJetPlots{false}; 
  bool doTrkInJetPlots_bjets{false}; 
  bool doTrkInJetPlots_matched{false}; 
  bool doTrkInJetPlots_matched_bjets{false}; 
  bool doTrkInJetPlots_fake{false}; 
  bool doTrkInJetPlots_fake_bjets{false}; 
  bool doTrkInJetPlots_unlinked{false}; 
  bool doTrkInJetPlots_unlinked_bjets{false}; 
  bool doTrkInJetPlots_truthFromB{false}; 
 
  bool doEfficienciesPerAuthor{false}; 
  bool doFakesPerAuthor{false};
  bool doTrackParametersPerAuthor{false};
  bool doResolutionsPerAuthor{false};
  bool doHitsRecoTracksPlotsPerAuthor{false};
  
  bool doNtupleTruthToReco{false}; 
 
  int detailLevel{10};
};
 
class InDetRttPlots: public InDetPlotBase {
public:
  InDetRttPlots(InDetPlotBase* pParent, const std::string& dirName, const InDetRttPlotConfig & config);
 
  void fill(const xAOD::TrackParticle& particle, const xAOD::TruthParticle& truthParticle, bool truthIsFromB=false, float mu = 0.0, float weight=1.0);
 
  void fill(const xAOD::TrackParticle& particle, float weight=1.0);
  void fill(const xAOD::TrackParticle& particle, const float mu, const unsigned int nVtx, float weight=1.0); //mu dependent plots
  void fill(const unsigned int ntracksFull, const unsigned int ntracksCentral,
        const unsigned int ntracksPt1GeV, const unsigned int truthMu,
        const float actualMu, const unsigned int nvertices, const float weight=1.0);
 
  void fill(const xAOD::TruthParticle& particle, float weight);
 
  void fillEfficiency(const xAOD::TruthParticle& truth, const xAOD::TrackParticle* track, const bool isGood, const unsigned int truthMu, const float actualMu, float weight);
  void fillTechnicalEfficiency(const xAOD::TruthParticle& truth, const bool isGood, const unsigned int truthMu, const float actualMu, float weight);
 
  void fillDuplicate(const xAOD::TruthParticle& truth,
             const std::vector<const xAOD::TrackParticle*>& tracks,
             float weight);
  
  void fill(const xAOD::VertexContainer& vertexContainer, const xAOD::Vertex* recoHardScatter, const std::vector<const xAOD::TruthVertex*>& truthHSVertices, const std::vector<const xAOD::TruthVertex*>& truthPUVertices, const float actualMu, float weight=1.0); 
  void fill(const xAOD::VertexContainer& vertexContainer, const unsigned int truthMu, const float actualMu, const float weight=1.0);
 
  void fill(const xAOD::TrackParticle& track, const xAOD::Jet& jet, bool isBjet=false, bool isFake=false, bool isUnlinked=false, bool truthIsFromB=false, const float weight=1.0);
  void fillEfficiency(const xAOD::TruthParticle& truth, const xAOD::Jet& jet, const bool isGood, bool isBjet=false, bool truthIsFromB=false, float weight=1.0);
  void fillFakeRate(const xAOD::TrackParticle& track, const xAOD::Jet& jet, const bool isFake, bool isBjet=false, bool truthIsFromB=false, float weight=1.0);
  
  void fillCounter(const unsigned int freq, const InDetPerfPlot_nTracks::CounterCategory counter, float weight);
  void fillFakeRate(const xAOD::TrackParticle& particle, const bool isFake, const bool isAssociatedTruth, const float mu, float weight);
 
  // fill IDPVM Ntuple
  void fillNtuple(const xAOD::TrackParticle& track, const xAOD::Vertex* vtx);
  void fillNtuple(const xAOD::TruthParticle& truth);
  void fillNtuple(const xAOD::TrackParticle& track, const xAOD::TruthParticle& truth, const xAOD::Vertex* vtx, const int truthMatchRanking); 
 
  virtual ~InDetRttPlots() {
  };
 
private:
  
  InDetRttPlotConfig m_config; 
 
  std::unique_ptr<InDetPerfPlot_TrackParameters> m_trackParameters;
  std::unique_ptr<InDetPerfPlot_nTracks> m_nTracks;
  std::unique_ptr<InDetPerfPlot_HitResidual> m_hitResidualPlot;
  std::unique_ptr<InDetPerfPlot_HitEfficiency> m_hitEffPlot;
  std::unique_ptr<InDetPerfPlot_FakeRate> m_fakePlots;
  std::unique_ptr<InDetPerfPlot_FakeRate> m_missingTruthFakePlots;
  std::unique_ptr<InDetPerfPlot_Resolution> m_resolutionPlotPrim;
  std::unique_ptr<InDetPerfPlot_Resolution> m_resolutionPlotPrim_truthFromB;
  std::unique_ptr<InDetPerfPlot_Hits> m_hitsRecoTracksPlots;
  std::unique_ptr<InDetPerfPlot_Efficiency> m_effPlots;
  std::unique_ptr<InDetPerfPlot_Duplicate> m_duplicatePlots;
  std::unique_ptr<InDetPerfPlot_VerticesVsMu> m_verticesVsMuPlots;
  std::unique_ptr<InDetPerfPlot_Vertex> m_vertexPlots;
  std::unique_ptr<InDetPerfPlot_Vertex> m_hardScatterVertexPlots;
  std::unique_ptr<InDetPerfPlot_VertexTruthMatching> m_hardScatterVertexTruthMatchingPlots;
  std::unique_ptr<InDetPerfPlot_TRTExtension> m_trtExtensionPlots;
  std::unique_ptr<InDetPerfNtuple_TruthToReco> m_ntupleTruthToReco;
  std::unique_ptr<InDetPerfPlot_Resolution> m_resolutionPlotSecd;
  std::unique_ptr<InDetPerfPlot_Hits> m_hitsMatchedTracksPlots;
  std::unique_ptr<InDetPerfPlot_Hits> m_hitsFakeTracksPlots;
  std::unique_ptr<InDetPerfPlot_Hits> m_hitsUnlinkedTracksPlots;
  std::unique_ptr<InDetPerfPlot_VertexTruthMatching> m_vertexTruthMatchingPlots;
  std::unique_ptr<InDetPerfPlot_TrkInJet> m_trkInJetPlots;
  std::unique_ptr<InDetPerfPlot_TrkInJet> m_trkInJetPlots_bjets;
  std::unique_ptr<InDetPerfPlot_TrkInJet> m_trkInJetPlots_matched;
  std::unique_ptr<InDetPerfPlot_TrkInJet> m_trkInJetPlots_matched_bjets;
  std::unique_ptr<InDetPerfPlot_TrkInJet> m_trkInJetPlots_fake;
  std::unique_ptr<InDetPerfPlot_TrkInJet> m_trkInJetPlots_fake_bjets;
  std::unique_ptr<InDetPerfPlot_TrkInJet> m_trkInJetPlots_unlinked;
  std::unique_ptr<InDetPerfPlot_TrkInJet> m_trkInJetPlots_unlinked_bjets;
  
  std::unique_ptr<InDetPerfPlot_TrkInJet> m_trkInJetPlots_truthFromB;
 
  std::unique_ptr<InDetPerfPlot_Efficiency> m_effSiSPSeededFinderPlots;
  std::unique_ptr<InDetPerfPlot_Efficiency> m_effInDetExtensionProcessorPlots;
  std::unique_ptr<InDetPerfPlot_Efficiency> m_effTRTSeededTrackFinderPlots;
  std::unique_ptr<InDetPerfPlot_Efficiency> m_effTRTStandalonePlots;
  std::unique_ptr<InDetPerfPlot_Efficiency> m_effSiSpacePointsSeedMaker_LargeD0Plots;
 
  std::unique_ptr<InDetPerfPlot_FakeRate> m_fakeSiSPSeededFinderPlots;
  std::unique_ptr<InDetPerfPlot_FakeRate> m_fakeInDetExtensionProcessorPlots;
  std::unique_ptr<InDetPerfPlot_FakeRate> m_fakeTRTSeededTrackFinderPlots;
  std::unique_ptr<InDetPerfPlot_FakeRate> m_fakeTRTStandalonePlots;
  std::unique_ptr<InDetPerfPlot_FakeRate> m_fakeSiSpacePointsSeedMaker_LargeD0Plots;
 
  std::unique_ptr<InDetPerfPlot_TrackParameters> m_trkParaSiSPSeededFinderPlots;
  std::unique_ptr<InDetPerfPlot_TrackParameters> m_trkParaInDetExtensionProcessorPlots;
  std::unique_ptr<InDetPerfPlot_TrackParameters> m_trkParaTRTSeededTrackFinderPlots;
  std::unique_ptr<InDetPerfPlot_TrackParameters> m_trkParaTRTStandalonePlots;
  std::unique_ptr<InDetPerfPlot_TrackParameters> m_trkParaSiSpacePointsSeedMaker_LargeD0Plots;
 
  std::unique_ptr<InDetPerfPlot_Resolution> m_resSiSPSeededFinderPlots;
  std::unique_ptr<InDetPerfPlot_Resolution> m_resInDetExtensionProcessorPlots;
  std::unique_ptr<InDetPerfPlot_Resolution> m_resTRTSeededTrackFinderPlots;
  std::unique_ptr<InDetPerfPlot_Resolution> m_resTRTStandalonePlots;
  std::unique_ptr<InDetPerfPlot_Resolution> m_resSiSpacePointsSeedMaker_LargeD0Plots;
 
  std::unique_ptr<InDetPerfPlot_Hits> m_hitsSiSPSeededFinderPlots;
  std::unique_ptr<InDetPerfPlot_Hits> m_hitsInDetExtensionProcessorPlots;
  std::unique_ptr<InDetPerfPlot_Hits> m_hitsTRTSeededTrackFinderPlots;
  std::unique_ptr<InDetPerfPlot_Hits> m_hitsTRTStandalonePlots;
  std::unique_ptr<InDetPerfPlot_Hits> m_hitsSiSpacePointsSeedMaker_LargeD0Plots;
};
 
 
 
 
#endif