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