TrackAnalysisPlotsMgr.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETTRACKPERFMON_TRACKANALYSISPLOTSMGR_H
#define INDETTRACKPERFMON_TRACKANALYSISPLOTSMGR_H
 
#include "xAODTracking/TrackParticle.h"
#include "xAODTruth/TruthParticle.h"
 
#include "InDetTrackPerfMon/ITrackAnalysisDefinitionSvc.h"
#include "PlotMgr.h"
#include "plots/TrackParametersPlots.h"
#include "plots/EfficiencyPlots.h"
#include "plots/OfflineElectronPlots.h"
#include "plots/ResolutionPlots.h"
#include "plots/FakeRatePlots.h"
#include "plots/DuplicateRatePlots.h"
#include "plots/HitsOnTracksPlots.h"
#include "plots/NtracksPlots.h"
 
#include <string>
#include <memory>
#include <vector>
 
 
namespace IDTPM {
 
  class TrackAnalysisCollections;
  class ITrackMatchingLookup;
 
  class TrackAnalysisPlotsMgr : public PlotMgr {
 
  public :
 
    TrackAnalysisPlotsMgr( const std::string& dirName,
                           const std::string& anaTag,
                           const std::string& chain,
                           PlotMgr* pParent = nullptr );
 
    virtual ~TrackAnalysisPlotsMgr() = default;
 
    StatusCode initialize();
 
    const std::string& anaTag() const { return m_anaTag; }
    const std::string& chain() const { return m_chain; }
    const std::string& directory() const { return m_directory; }
 
    StatusCode fill( TrackAnalysisCollections& trkAnaColls, float weight=1.0 );
 
    template< typename PARTICLE > 
    StatusCode fillPlotsTest(
        const std::vector< const PARTICLE* >& particles,
        const ITrackMatchingLookup& matches,
        float truthMu=0., float actualMu=0., float weight=1.0 );
 
    template< typename PARTICLE > 
    StatusCode fillPlotsReference(
        const std::vector< const PARTICLE* >& particles,
        const ITrackMatchingLookup& matches,
        float truthMu=0., float actualMu=0., float weight=1.0 );
 
    StatusCode fillPlotsTruth(
        const std::vector< const xAOD::TrackParticle* >& testTracks,
        const std::vector< const xAOD::TrackParticle* >& refTracks,
        const std::vector< const xAOD::TruthParticle* >& truths,
        const ITrackMatchingLookup& matches,
        float truthMu=0., float actualMu=0., float weight=1.0 );
 
  private :
 
    std::string m_anaTag;
    std::string m_chain;
    std::string m_directory;
 
    SmartIF<ITrackAnalysisDefinitionSvc> m_trkAnaDefSvc;
 
    std::unique_ptr< TrackParametersPlots >  m_plots_trkParam_vsTest;
    std::unique_ptr< EfficiencyPlots >       m_plots_eff_vsTest;
    std::unique_ptr< EfficiencyPlots >       m_plots_tech_eff_vsTest;
    std::unique_ptr< HitsOnTracksPlots >     m_plots_hitsOnTrk_vsTest;
    std::unique_ptr< HitsOnTracksPlots >     m_plots_hitsOnMatchedTrk;
    std::unique_ptr< NtracksPlots >          m_plots_nTracks_test;
    std::unique_ptr< TrackParametersPlots >  m_plots_trkParam_vsRef;
    std::unique_ptr< EfficiencyPlots >       m_plots_eff_vsRef;
    std::unique_ptr< EfficiencyPlots >       m_plots_tech_eff_vsRef;
    std::unique_ptr< HitsOnTracksPlots >     m_plots_hitsOnTrk_vsRef;
    std::unique_ptr< HitsOnTracksPlots >     m_plots_hitsOnMatchedTrk_vsRef;
    std::unique_ptr< NtracksPlots >          m_plots_nTracks_ref;
    std::unique_ptr< EfficiencyPlots >       m_plots_eff_vsTruth;
    std::unique_ptr< EfficiencyPlots >       m_plots_tech_eff_vsTruth;
    std::unique_ptr< ResolutionPlots >       m_plots_resolution;
    std::unique_ptr< FakeRatePlots >         m_plots_fakeRate;
    std::unique_ptr< FakeRatePlots >         m_plots_missingTruth;
    std::unique_ptr< HitsOnTracksPlots >     m_plots_hitsOnFakeTrk;
    std::unique_ptr< HitsOnTracksPlots >     m_plots_hitsOnUnlinkedTrk;
    std::unique_ptr< DuplicateRatePlots >    m_plots_duplRate;
    std::unique_ptr< OfflineElectronPlots >  m_plots_offEle;
    std::unique_ptr< OfflineElectronPlots >  m_plots_eff_vsOffEle;
 
  }; // class TrackAnalysisPlotsMgr
 
} // namespace IDTPM
 
#endif // > !INDETTRACKPERFMON_TRACKANALYSISPLOTSMGR_H