BeamspotVertexPreProcessor.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef  TRKALIGNGENTOOLS_BEAMSPOTVERTEXPREPROCESSOR_H
#define  TRKALIGNGENTOOLS_BEAMSPOTVERTEXPREPROCESSOR_H
 
#include "TrkVertexFitterInterfaces/ITrackToVertexIPEstimator.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/IAlgTool.h"
#include "AthenaBaseComps/AthAlgTool.h"
#include "TrkAlignInterfaces/IAlignTrackPreProcessor.h"
#include "TrkEventPrimitives/ParticleHypothesis.h"
#include <limits>
#include "VxVertex/VxContainer.h"
#include <functional>
 
#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
 
#include "xAODTracking/TrackParticle.h"
#include "xAODTracking/Vertex.h"
#include "xAODTracking/VertexContainer.h"
#include "BeamSpotConditionsData/BeamSpotData.h"
 
namespace Trk {
  class IGlobalTrackFitter;
  class IExtrapolator;
  //class ITrackSelectorTool;
  class Track;
  class AlignTrack;
  class AlignVertex;
  class VxCandidate;
  class VertexOnTrack;
  class VxTrackAtVertex;
  class IAlignModuleTool;
 
  class BeamspotVertexPreProcessor : virtual public Trk::IAlignTrackPreProcessor, public AthAlgTool
  {
 
  public:
 
    BeamspotVertexPreProcessor(const std::string & type, const std::string & name, const IInterface * parent);
    virtual ~BeamspotVertexPreProcessor();
 
    virtual StatusCode initialize();
    virtual StatusCode finalize();
 
    virtual DataVector<Track> * processTrackCollection(const DataVector<Track> * trks);
 
    void accumulateVTX(AlignTrack* alignTrack);
 
    void solveVTX();
 
    virtual void printSummary();
 
 
 
  private:
 
    void  prepareAllTracksVector();
 
    bool  isAssociatedToPV(const Track * track, const xAOD::VertexContainer* vertices);
    bool  isAssociatedToVertex(const Track * track, const xAOD::Vertex * vertex);
 
    bool  selectVertices(const xAOD::Vertex * vtx) const;
    bool  selectUpdatedVertices(const xAOD::Vertex * updatedVtx) const;
    
    const xAOD::Vertex* findVertexCandidate(const Track* track) const; // MD: changed to be now only a vertex
    const VertexOnTrack* provideVotFromVertex(const Track* track, const xAOD::Vertex* &vtx) const;
    const VertexOnTrack* provideVotFromBeamspot(const Track* track) const;
    void provideVtxBeamspot(const AlignVertex* b, AmgSymMatrix(3)* q, Amg::Vector3D* v) const;
 
 
    const Track* doConstraintRefit(ToolHandle<IGlobalTrackFitter>& fitter, const Track* track,  const VertexOnTrack* vot, const ParticleHypothesis& particleHypothesis) const;
    bool  doBeamspotConstraintTrackSelection(const Track* track);
    AlignTrack* doTrackRefit(const Track* track);
 
 
 
    ToolHandle<IGlobalTrackFitter>    m_trackFitter;     
    ToolHandle<IGlobalTrackFitter>    m_SLTrackFitter;   
    ToolHandle<IExtrapolator>         m_extrapolator;    
    //ToolHandle<ITrackSelectorTool>    m_trkSelector;     //!< track selector tool
    ToolHandle<InDet::IInDetTrackSelectionTool> m_trkSelector; 
    //ToolHandle<ITrackSelectorTool>    m_BSTrackSelector; //!< track selector tool for tracks to be used with beam-spot constraint
    ToolHandle<InDet::IInDetTrackSelectionTool> m_BSTrackSelector; 
    //MD:
    ToolHandle<ITrackToVertexIPEstimator>        m_trackToVertexIPEstimatorTool; 
    
    ToolHandle <Trk::IAlignModuleTool> m_alignModuleTool;
    
    SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
 
    std::string m_PVContainerName;                       
    bool m_runOutlierRemoval;                            
    bool m_selectVertices;                           
    int  m_particleNumber;                           
    bool m_doTrkSelection;                               
    bool m_doBSTrackSelection;                           
    bool m_doAssociatedToPVSelection;                
 
    unsigned int m_constraintMode;
 
    std::string m_compareMethod;             
    std::vector<std::string> m_interestedVertexContainers;
    std::vector< std::pair< const xAOD::Vertex*, std::vector<VxTrackAtVertex> > >  m_allTracksVector;
    bool m_doBeamspotConstraint;                 
    bool m_doPrimaryVertexConstraint;            
    bool m_doFullVertexConstraint;                       
    bool m_doNormalRefit;                                
    
    double m_maxPt;                             
 
    bool m_refitTracks;                       
    bool m_storeFitMatrices;                     
    bool m_useSingleFitter;                   
    double m_BSScalingFactor;               
    double m_PVScalingFactor;               
 
    int m_minTrksInVtx;                     
    int m_nTracks;
    std::vector<int> m_trackTypeCounter;
    int m_nFailedNormalRefits;
    int m_nFailedBSRefits;
    int m_nFailedPVRefits;
 
    DataVector<AlignVertex> m_AlignVertices;             
 
 
  };
 
 
 
  class CompareTwoTracks {
 
    public:
         CompareTwoTracks(const Track* track, const std::string& compareMethod)
         :m_method(compareMethod)
         ,m_track(track)
         { //std::cout <<"compareMethod: "<< m_method <<std::endl; 
         }
 
    bool operator()(VxTrackAtVertex vtxTrk);
 
    private:
         std::string m_method;
         const Track* m_track;
  };
 
 
}
 
#endif // TRKALIGNGENTOOLS_BEAMSPOTVERTEXPREPROCESSOR_H