AdaptiveMultiVertexFitter.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef TRKVERTEXFITTERS_ADAPTIVEMULTIVERTEXFITTER_H
#define TRKVERTEXFITTERS_ADAPTIVEMULTIVERTEXFITTER_H
 
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
 
//xAOD includes
#include "xAODTracking/Vertex.h"
#include <vector>
//
#include "TrkVertexFitterInterfaces/IImpactPoint3dEstimator.h"
#include "TrkVertexFitterInterfaces/IVertexAnnealingMaker.h"
#include "TrkVertexFitterInterfaces/IVertexLinearizedTrackFactory.h"
#include "TrkVertexFitterInterfaces/IVertexSmoother.h"
#include "TrkVertexFitterInterfaces/IVertexTrackCompatibilityEstimator.h"
#include "TrkVertexFitterInterfaces/IVertexUpdator.h"
namespace Trk
{
 
  static const InterfaceID IID_AdaptiveMultiVertexFitter("AdaptiveMultiVertexFitter", 1, 0);
 
 
  //  class MeasuredPerigee;
  class Track;
  class VxTrackAtVertex;
 
  class TrackToVtxLink;
 
  class AdaptiveMultiVertexFitter : public AthAlgTool
  {
  public:
    StatusCode initialize();
    StatusCode finalize();
  
    
    AdaptiveMultiVertexFitter(const std::string& t, const std::string& n, const IInterface*  p);
 
    virtual ~AdaptiveMultiVertexFitter();
 
    void 
    fit(std::vector<xAOD::Vertex*> & allVertices) const;
 
    void 
    addVtxToFit(xAOD::Vertex* pVtx) const; 
    //
    void 
    addVtxTofit(xAOD::Vertex* pVtx)  const { return addVtxToFit(pVtx);}
    
    static const InterfaceID& 
    interfaceID() {
      return IID_AdaptiveMultiVertexFitter;
    }
   
  private:
 
    static bool 
    findAmongVertices(const xAOD::Vertex* vertex,const std::vector<xAOD::Vertex*> & previousVertices) ;
 
    std::vector<double> 
    collectWeights(TrackToVtxLink & tracklink) const;
 
    void 
    prepareCompatibility(xAOD::Vertex* newvertex) const;
 
    long int 
    m_maxIterations;
 
    
    double 
    m_maxDistToLinPoint;
    
    double 
    m_initialError;
 
    bool 
    m_doSmoothing;
 
    double 
    m_minweight;
 
    double 
    m_maxRelativeShift;
 
    ToolHandle<Trk::IVertexLinearizedTrackFactory> m_LinearizedTrackFactory{
      this,
      "LinearizedTrackFactory",
      "Trk::FullLinearizedTrackFactory"
    };
    ToolHandle<Trk::IVertexTrackCompatibilityEstimator>
      m_TrackCompatibilityEstimator{ this,
                                     "TrackCompatibilityEstimator",
                                     "Trk::Chi2TrackCompatibilityEstimator" };
    ToolHandle<Trk::IImpactPoint3dEstimator> m_ImpactPoint3dEstimator{
      this,
      "ImpactPoint3dEstimator",
      "Trk::ImpactPoint3dEstimator/ImpactPoint3dEstimator"
    };
 
    ToolHandle<Trk::IVertexUpdator> m_VertexUpdator{
      this,
      "VertexUpdator",
      "Trk::KalmanVertexUpdator"
    };
    ToolHandle<Trk::IVertexSmoother> m_VertexSmoother{
      this,
      "VertexSmoother",
      "Trk::SequentialVertexSmoother"
    };
    ToolHandle<Trk::IVertexAnnealingMaker> m_AnnealingMaker{
      this,
      "AnnealingMaker",
      "Trk::DetAnnealingMaker"
    };
  };
}
 
#endif