JetFitterRoutines.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef TrkJetFitter_JetFitterRoutines_H
#define TrkJetFitter_JetFitterRoutines_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
#include "StoreGate/ReadCondHandleKey.h"
 
#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
 
namespace Trk {
 
  class VxVertexOnJetAxis;
  class VxJetCandidate;
  class JetFitterInitializationHelper;
  class JetFitterHelper;
  class KalmanVertexOnJetAxisUpdator;
  class KalmanVertexOnJetAxisSmoother;
  class TrkDistanceFinderNeutralCharged;
  class TrkDistanceFinderNeutralNeutral;
 
  static const InterfaceID IID_JetFitterRoutines("Trk::JetFitterRoutines", 1, 0);
 
  class JetFitterRoutines : public AthAlgTool
  {
 
  public:
 
    static const InterfaceID& interfaceID() {
      return IID_JetFitterRoutines;
    }
 
 
    virtual StatusCode initialize() override;

 
    JetFitterRoutines(const std::string& t, const std::string& n, const IInterface*  p);

 
    ~JetFitterRoutines();

 
    void initializeToMinDistancesToJetAxis(VxJetCandidate*) const;

 
    void performTheFit(VxJetCandidate* myJetCandidate,
               int num_maxiterations=30,
               bool treat_sign_flip=true,
               int num_signflip_maxiterations=30,
               double deltachi2_convergence=0.001) const;

 
    void smoothAllVertices(VxJetCandidate* myJetCandidate) const;

 
    void updateAllVertices(VxJetCandidate* myJetCandidate) const ;
 
    //    void updateChi2AllVertices(VxJetCandidate* myJetCandidate) const ;

 
    std::pair<double,bool> fastProbabilityOfMerging(const VxVertexOnJetAxis*,const VxVertexOnJetAxis*,
                            const VxJetCandidate*) const;

 
 
    double fullProbabilityOfMerging(const VxVertexOnJetAxis* firstVertex,
                    const VxVertexOnJetAxis* secondVertex,
                    const VxJetCandidate* myJetCandidate,
                    int num_maxiterations=20,
                    bool treat_sign_flip=true,
                    int num_signflip_maxiterations=10,
                    double deltachi2_convergence=1e-2) const;
 
    void fillTableWithFullProbOfMerging(VxJetCandidate* myJetCandidate,
                    int num_maxiterations=20,
                    bool treat_sign_flip=true,
                    int num_signflip_maxiterations=10,
                    double deltachi2_convergence=1e-3,
                    double threshold_probability=1e-5) const;
 

 
 
    void fillTableWithFastProbOfMerging(VxJetCandidate* myJetCandidate) const;
    //please note that in the case of FastProbOfMerging the threshold_probability is always 1e-3
    //(the default one for the FullProb - see three lines above)

 
    void deleteVertexFromJetCandidate(VxVertexOnJetAxis* vertexToDelete,
                      VxJetCandidate* myJetCandidate) const;
 
  private:

 
    std::pair<double,bool> fastProbabilityOfMergingWithPrimary(const VxVertexOnJetAxis* otherVertex,
                                   const VxJetCandidate* myJetCandidate) const;
      
 
    std::pair<double,bool> fastProbabilityOfMergingNoPrimary(const VxVertexOnJetAxis*,
                                 const VxVertexOnJetAxis*,
                                 const VxJetCandidate* myJetCandidate) const;

    
    void fillTableWithProbOfMerging(VxJetCandidate* myJetCandidate,
                    bool fullcomputation,
                    int num_maxiterations=20,
                    bool treat_sign_flip=true,
                    int num_signflip_maxiterations=10,
                    double deltachi2_convergence=1e-2,
                    double threshold_probability=1e-3) const;
 
    bool checkJetCandidate(VxJetCandidate*) const;

    void copyRecoPositionsToLinearizationPositions(VxJetCandidate & myJetCandidate) const;
 
    SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCacheCondObjInputKey
       {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"};
 
    ToolHandle<JetFitterInitializationHelper> m_initializationHelper;
    ToolHandle<JetFitterHelper> m_helper;
    ToolHandle<KalmanVertexOnJetAxisUpdator> m_updator;
    ToolHandle<KalmanVertexOnJetAxisSmoother> m_smoother;
    ToolHandle<TrkDistanceFinderNeutralCharged> m_minDistanceFinder;
    ToolHandle<TrkDistanceFinderNeutralNeutral> m_minDistanceFinderNeutral;
    
 
    /*
     * Old option: please do not switch to true.
     * Will be deleted in future releases.
     */
 
    bool m_fast;
 
    /*
     * Provides a limit to the DR shifht of the direction of the flight axis during 
     * the fast estimation procedure for the probability of merging between to vertices.
     * If the shift is higher than that, the fastProbabilityOfMerging method informs 
     * the user that the estimation could not be reliable.
     */
 
    double m_maxDRshift;
 
    /*
     * If true, the assumption is made that, whenever tracks are merged to the primary vertex, they were already 
     * contained in the primary vertex fit, for which the prior information about the position and covariance matrix 
     * was already used in initializing the fit.
     *
     * This has the problem that if this was not the case and smoothing of the tracks at the primary vertex is requested, 
     * sometimes a negative weight can come out of the removal of the track (is this is particularly affecting the fit).
     *
     * Unless you know what you are doing, put this to false.
     *
     * Also in this case there is a disadvantage: tracks are refit again into the primary vertex, even if they were 
     * already partecipating in the prior information of the vertex. This will be resolved only when the primary and 
     * secondary vertex fit will be related the one to the other.
     */
 
    bool m_noPrimaryVertexRefit;
 
    /*
     * Avoid vertex to be initialize outside ID envelope given bu m_maxR and m_maxZ
     */
 
    double m_maxR;
    double m_maxZ;
 
  };//end class declaration
 
}//end namespace Trk
 
 
#endif