TrackAnalysisCollections.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETTRACKPERFMON_TRACKANALYSISCOLLECTIONS_H
#define INDETTRACKPERFMON_TRACKANALYSISCOLLECTIONS_H
 
#include "AthenaBaseComps/AthMsgStreamMacros.h"
#include "AthenaBaseComps/AthCheckMacros.h"
#include "AthenaBaseComps/AthMessaging.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/Service.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadHandle.h"
 
#include "xAODEventInfo/EventInfo.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTruth/TruthParticleContainer.h"
#include "xAODTruth/TruthEventContainer.h"
#include "xAODTruth/TruthPileupEventContainer.h"
#include "xAODTracking/VertexContainer.h"
 
#include "InDetTrackPerfMon/ITrackAnalysisDefinitionSvc.h"
#include "ITrackMatchingLookup.h"
 
#include <string>
#include <vector>
#include <memory>
#include <unordered_map>
#include <utility>
 
 
namespace IDTPM {
 
  class TrackAnalysisCollections : public AthMessaging {
 
  public:
 
    enum Stage : size_t { FULL, FS, InRoI, NStages };
 
    enum Counter : size_t { ALL, SELECTED, INROI, MATCHED, NCOUNTERS };
 
    TrackAnalysisCollections( const std::string& anaTag );
 
    ~TrackAnalysisCollections() = default;
 
    TrackAnalysisCollections& operator=( const TrackAnalysisCollections& ) = delete;
 
    StatusCode initialize();
 
 
    StatusCode fillEventInfo(
        const SG::ReadHandleKey<xAOD::EventInfo>& eventInfoHandleKey,
        const SG::ReadHandleKey< xAOD::TruthEventContainer >& truthEventHandleKey,
        const SG::ReadHandleKey< xAOD::TruthPileupEventContainer >& truthPUEventHandleKey );
 
    StatusCode fillTruthPartContainer(
        const SG::ReadHandleKey< xAOD::TruthParticleContainer >& truthPartHandleKey );
 
    StatusCode fillOfflTrackContainer(
        const SG::ReadHandleKey<xAOD::TrackParticleContainer>& handleKey );
 
    StatusCode fillTrigTrackContainer(
        const SG::ReadHandleKey<xAOD::TrackParticleContainer>& handleKey );
 
    StatusCode fillTestTruthVec(
        const std::vector< const xAOD::TruthParticle* >& vec,
        Stage stage = FULL );
 
    StatusCode fillTestTrackVec(
        const std::vector< const xAOD::TrackParticle* >& vec,
        Stage stage = FULL );
 
    StatusCode fillRefTruthVec(
        const std::vector< const xAOD::TruthParticle* >& vec,
        Stage stage = FULL );
 
    StatusCode fillRefTrackVec(
        const std::vector< const xAOD::TrackParticle* >& vec,
        Stage stage = FULL );
 
    StatusCode fillTruthPartVec(
        const std::vector< const xAOD::TruthParticle* >& vec,
        Stage stage = FULL );
 
    StatusCode fillOfflTrackVec(
        const std::vector< const xAOD::TrackParticle* >& vec,
        Stage stage = FULL );
 
    StatusCode fillTrigTrackVec(
        const std::vector< const xAOD::TrackParticle* >& vec,
        Stage stage = FULL );
 
    StatusCode fillTruthVertexContainer(
        const SG::ReadHandleKey< xAOD::TruthVertexContainer >& truthVertexHandleKey );
 
    StatusCode fillOfflVertexContainer(
        const SG::ReadHandleKey< xAOD::VertexContainer >& handleKey );
 
    StatusCode fillTrigVertexContainer(
        const SG::ReadHandleKey< xAOD::VertexContainer >& handleKey );
 
    StatusCode fillTestTruthVertexVec(
        const std::vector< const xAOD::TruthVertex* >& vec,
        Stage stage = FULL );
 
    StatusCode fillTestRecoVertexVec(
        const std::vector< const xAOD::Vertex* >& vec,
        Stage stage = FULL );
 
    StatusCode fillRefTruthVertexVec(
        const std::vector< const xAOD::TruthVertex* >& vec,
        Stage stage = FULL );
 
    StatusCode fillRefRecoVertexVec(
        const std::vector< const xAOD::Vertex* >& vec,
        Stage stage = FULL );
 
    StatusCode fillTruthVertexVec(
        const std::vector< const xAOD::TruthVertex* >& vec,
        Stage stage = FULL );
 
    StatusCode fillOfflVertexVec(
        const std::vector< const xAOD::Vertex* >& vec,
        Stage stage = FULL );
 
    StatusCode fillTrigVertexVec(
        const std::vector< const xAOD::Vertex* >& vec,
        Stage stage = FULL );
 
 
    bool isNewEvent() { return ( m_newChain && m_newRoi ); }
 
    bool isNewChain() { return m_newChain; }
 
    void newChain() { m_newChain = false; m_newRoi = true; }
 
    bool isNewRoI() { return m_newRoi; }
 
    void newRoI() { m_newRoi = false; }
 
    bool empty( Stage stage = FULL );
 
    void clear( Stage stage = FULL );
 
    void copyFS();
 
    std::string printInfo( Stage stage = FULL, bool printVertex = true ) const;
 
    std::string printVertexInfo( Stage stage = FULL ) const;
 
 
    const std::string& anaTag() { return m_anaTag; }
 
    const xAOD::EventInfo* eventInfo() { return m_eventInfo; }
    const xAOD::TruthEventContainer* truthEventContainer() { return m_truthEventContainer; }
    const xAOD::TruthPileupEventContainer* truthPileupEventContainer() { return m_truthPUEventContainer; }
 
    const xAOD::TruthParticleContainer* testTruthContainer();
    const xAOD::TrackParticleContainer* testTrackContainer();
 
    const xAOD::TruthParticleContainer* refTruthContainer();
    const xAOD::TrackParticleContainer* refTrackContainer();
 
    const xAOD::TruthParticleContainer* truthPartContainer() {
      return m_truthPartContainer; }
    const xAOD::TrackParticleContainer* offlTrackContainer() {
      return m_offlTrackContainer; }
    const xAOD::TrackParticleContainer* trigTrackContainer() {
      return m_trigTrackContainer; }
 
    const std::vector< const xAOD::TruthParticle* >& testTruthVec( Stage stage = FULL );
    const std::vector< const xAOD::TrackParticle* >& testTrackVec( Stage stage = FULL );
 
    const std::vector< const xAOD::TruthParticle* >& refTruthVec( Stage stage = FULL );
    const std::vector< const xAOD::TrackParticle* >& refTrackVec( Stage stage = FULL );
 
    const std::vector< const xAOD::TruthParticle* >& truthPartVec( Stage stage = FULL ) {
      return m_truthPartVec[ stage ]; }
    const std::vector< const xAOD::TrackParticle* >& offlTrackVec( Stage stage = FULL ) {
      return m_offlTrackVec[ stage ]; }
    const std::vector< const xAOD::TrackParticle* >& trigTrackVec( Stage stage = FULL ) {
      return m_trigTrackVec[ stage ]; }
 
    std::vector< size_t > testTrackCounts();
    std::vector< size_t > refTrackCounts();
 
    const xAOD::TruthVertexContainer* testTruthVertexContainer();
    const xAOD::VertexContainer*      testRecoVertexContainer();
 
    const xAOD::TruthVertexContainer* refTruthVertexContainer();
    const xAOD::VertexContainer*      refRecoVertexContainer();
 
    const xAOD::TruthVertexContainer* truthVertexContainer() {
      return m_truthVertexContainer; }
    const xAOD::VertexContainer* offlVertexContainer() {
      return m_offlVertexContainer; }
    const xAOD::VertexContainer* trigVertexContainer() {
      return m_trigVertexContainer; }
 
    const std::vector< const xAOD::TruthVertex* >&  testTruthVertexVec( Stage stage = FULL );
    const std::vector< const xAOD::Vertex* >&       testRecoVertexVec( Stage stage = FULL );
 
    const std::vector< const xAOD::TruthVertex* >&  refTruthVertexVec( Stage stage = FULL );
    const std::vector< const xAOD::Vertex* >&       refRecoVertexVec( Stage stage = FULL );
 
    const std::vector< const xAOD::TruthVertex* >& truthVertexVec( Stage stage = FULL ) {
      return m_truthVertexVec[ stage ]; }
    const std::vector< const xAOD::Vertex* >& offlVertexVec( Stage stage = FULL ) {
      return m_offlVertexVec[ stage ]; }
    const std::vector< const xAOD::Vertex* >& trigVertexVec( Stage stage = FULL ) {
      return m_trigVertexVec[ stage ]; }
 
    std::vector< size_t > testVertexCounts();
    std::vector< size_t > refVertexCounts();
 
    ITrackMatchingLookup& matches() { return *m_matches; }
 
    std::string printMatchInfo();
 
    bool updateChainRois( const std::string& chainRoi, const std::string& roiStr );
 
  private:
 
    std::string m_anaTag;
    SmartIF< ITrackAnalysisDefinitionSvc > m_trkAnaDefSvc;
    bool m_newChain, m_newRoi;
 
    const xAOD::EventInfo* m_eventInfo{nullptr};
    const xAOD::TruthEventContainer* m_truthEventContainer{nullptr};
    const xAOD::TruthPileupEventContainer* m_truthPUEventContainer{nullptr};
 
    const xAOD::TruthParticleContainer* m_truthPartContainer{nullptr};
    const xAOD::TrackParticleContainer* m_offlTrackContainer{nullptr};
    const xAOD::TrackParticleContainer* m_trigTrackContainer{nullptr};
 
    std::vector<std::vector< const xAOD::TruthParticle* >> m_truthPartVec{};
    std::vector<std::vector< const xAOD::TrackParticle* >> m_offlTrackVec{};
    std::vector<std::vector< const xAOD::TrackParticle* >> m_trigTrackVec{};
 
    const xAOD::TruthVertexContainer* m_truthVertexContainer{nullptr};
    const xAOD::VertexContainer*      m_offlVertexContainer{nullptr};
    const xAOD::VertexContainer*      m_trigVertexContainer{nullptr};
 
    std::vector<std::vector< const xAOD::TruthVertex* >>  m_truthVertexVec{};
    std::vector<std::vector< const xAOD::Vertex* >>       m_offlVertexVec{};
    std::vector<std::vector< const xAOD::Vertex* >>       m_trigVertexVec{};
 
    std::vector< const xAOD::TrackParticle* > m_nullTrackVec{};
    std::vector< const xAOD::TruthParticle* > m_nullTruthVec{};
    std::vector< const xAOD::TruthVertex* >   m_nullTruthVertVec{};
    std::vector< const xAOD::Vertex* >        m_nullRecoVertVec{};
 
    std::unique_ptr< ITrackMatchingLookup > m_matches;
 
    typedef std::unordered_map< std::string, std::string > mapChainRoi_t;
    mapChainRoi_t m_chainRois{};
 
  }; // class TrackAnalysisCollections
 
} // namespace IDTPM
 
#endif // > !INDETTRACKPERFMON_TRACKANALYSISCOLLECTIONS_H