BPhysTrackVertexMapTool.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: $
#ifndef BPHYSTOOLS_BPHYSTRACKVERTEXMAPTOOL_H
#define BPHYSTOOLS_BPHYSTRACKVERTEXMAPTOOL_H
 
// Framework includes
#include "BPhysTools/IBPhysTrackVertexMapTool.h"
#include "AsgTools/AsgTool.h"
 
// EDM includes
#include "xAODTracking/TrackParticleAuxContainer.h"
#include "xAODTracking/VertexAuxContainer.h"
// System include(s):
#include <vector>
#include <string>
#include <map>
 
namespace xAOD {
  class BPhysTrackVertexMapTool :
    public asg::AsgTool, virtual public xAOD::IBPhysTrackVertexMapTool {
    
    ASG_TOOL_CLASS( BPhysTrackVertexMapTool, xAOD::IBPhysTrackVertexMapTool )
    
   public:
    BPhysTrackVertexMapTool(const std::string& name =
                "BPhysTrackVertexMapTool");

    virtual StatusCode initialize() override;
    
    virtual StatusCode logEvent() override;

    virtual StatusCode finalize() override;

    virtual bool doLog() const override;

    static std::string wrapLines(const std::string& lines, const std::string& prefix);
 
  protected:
    virtual StatusCode cacheEvent() override;

    virtual std::vector<const xAOD::Vertex*>
    pvsForIDTrack(const xAOD::TrackParticle* track) const override;
    
    virtual std::vector<const xAOD::Vertex*>
    refPVsForIDTrack(const xAOD::TrackParticle* track) const override;
    
    virtual std::vector<const xAOD::Vertex*>
    svsForIDTrack(const xAOD::TrackParticle* track) const override;
    
    // track-vertex association related
    virtual std::string idTrackToString(const xAOD::TrackParticle* track,
                    unsigned int indent=0,
                    bool withPV=false,
                    bool withRefPV=false,
                    bool withSV=false) override;
    
    virtual std::string pvToString(const xAOD::Vertex* vtx,
                   unsigned int indent=0,
                   bool withTracks=false) override;
    
    virtual std::string refPVToString(const xAOD::Vertex* vtx,
                      unsigned int indent=0,
                      bool withTracks=false) override;
    virtual std::string svToString(const xAOD::Vertex* vtx,
                   unsigned int indent=0,
                   bool withTracks=false,
                   bool withMasses=false) override;
    virtual std::string idTracksToString(const xAOD::TrackParticleContainer*
                     tpc,
                     unsigned int indent=0,
                     bool withPV=false,
                     bool withRefPV=false,
                     bool withSV=false) override;
    
    virtual std::string pvsToString(const xAOD::VertexContainer* pvc,
                    unsigned int indent=0,
                    bool withTracks=false) override;
    virtual std::string refPVsToString(const xAOD::VertexContainer* rpvc,
                       unsigned int indent=0,
                       bool withTracks=false) override;
    virtual std::string svsToString(const xAOD::VertexContainer* svc,
                    unsigned int indent=0,
                    bool withTracks=false,
                    bool withMasses=false) override;
    virtual std::string summaryToString(std::string prefix) override;
 
  protected:
    virtual float getFloat(std::string name, const xAOD::Vertex* b);
 
    virtual std::vector<std::string> getTokens(std::string input,
                           std::string seperators);
 
 
  private:
    // track-vertex association related
    typedef std::map<const xAOD::TrackParticle*,
             std::vector<const xAOD::Vertex*> > TrackToVertexMap_t;
    
    virtual void initTrackVertexMaps(const xAOD::TrackParticleContainer* tpc,
                     const xAOD::VertexContainer* pvc, 
                     const xAOD::VertexContainer* rpvc,
                     const xAOD::VertexContainer* svc);
    virtual void addVertexToTrackVertexMap(TrackToVertexMap_t& map,
                       const xAOD::TrackParticle* track,
                       const xAOD::Vertex* vtx);
    virtual std::string pvName(const xAOD::Vertex* vtx);
    virtual std::string refPVName(const xAOD::Vertex* vtx);
    virtual std::string svName(const xAOD::Vertex* vtx);
    virtual std::string idTrackName(const xAOD::TrackParticle* vtx);
    
  protected:      
    // job options
    std::string  m_vertexContainerName;
    std::string  m_refPVContainerName;
    std::string  m_pvContainerName;
    std::string  m_trackParticleContainerName;
    int          m_debugTrkToVtxMaxEvents;
    std::string  m_dumpPrefix;
    std::string  m_hypoName;
    
    // containers
    const xAOD::TrackParticleContainer*    m_tracks;
    const xAOD::TrackParticleAuxContainer* m_tracksAux;
    const xAOD::VertexContainer*           m_pvtxContainer;
    const xAOD::VertexContainer*           m_svtxContainer;
    const xAOD::VertexAuxContainer*        m_svtxAuxContainer;
    const xAOD::VertexContainer*           m_refPVContainer;
    const xAOD::VertexAuxContainer*        m_refPVAuxContainer;
    
    unsigned int m_nEvtsSeen;
 
    int          m_cachedRun;
    int          m_cachedEvent;
    
  private:
    // track-vertex association related
    typedef std::map<const xAOD::Vertex*, std::string> VertexNameMap_t;
    VertexNameMap_t m_pvNameMap;
    VertexNameMap_t m_refPVNameMap;
    VertexNameMap_t m_svNameMap;
    
    typedef std::map<const xAOD::TrackParticle*, std::string> TrackNameMap_t;
    TrackNameMap_t  m_idTrackNameMap;
 
    TrackToVertexMap_t m_idTrackToPVMap;
    TrackToVertexMap_t m_idTrackToRefPVMap;
    TrackToVertexMap_t m_idTrackToSVMap;
        
  }; // class BPhysTrackVertexMapTool
 
} // namespace xAOD
 
#endif // BPHYSTOOLS_BPHYSTRACKVERTEXMAPTOOL_H