InDetV0FinderTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
/***************************************************************************
                          InDetV0FinderTool.h  -  Description
                             -------------------
    begin   : 30-11-2014
    authors : Evelina Bouhova-Thacker (Lancater University)
    email   : e.bouhova@cern.ch
    changes :
 
 ***************************************************************************/
 
#ifndef INDETV0FINDERTOOL_H
#define INDETV0FINDERTOOL_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
#include "xAODTracking/VertexContainer.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "StoreGate/WriteDecorHandleKey.h"
#include "StoreGate/ReadDecorHandleKey.h"
#include "StoreGate/ReadDecorHandleKeyArray.h"
#include "xAODEventInfo/EventInfo.h"
#include "BeamSpotConditionsData/BeamSpotData.h"
#include "TrkParameters/TrackParameters.h"
#include "GeoPrimitives/GeoPrimitives.h" //Needed for Amg::Vector3D
#include <atomic>
/* Forward declarations */
 
namespace Trk
{
  class IVertexFitter;
  class TrkV0VertexFitter;
  class V0Tools;
  class IExtrapolator;
  class ITrackSelectorTool;
}
 
namespace HepPDT{
  class ParticleDataTable;
}
 
namespace Reco{
  class ITrackToVertex;
}
 
namespace InDet
{
  class VertexPointEstimator;
 
  static const InterfaceID IID_InDetV0FinderTool("InDetV0FinderTool", 1, 0);
 
  class InDetV0FinderTool:  public AthAlgTool
  {
  public:
    InDetV0FinderTool(const std::string& t, const std::string& n, const IInterface*  p);
    ~InDetV0FinderTool();
    StatusCode initialize();
    StatusCode finalize();
 
    static const InterfaceID& interfaceID() { return IID_InDetV0FinderTool;}
 
    StatusCode performSearch(xAOD::VertexContainer* v0Container,
                             xAOD::VertexContainer* ksContainer,
                             xAOD::VertexContainer* laContainer,
                             xAOD::VertexContainer* lbContainer,
                             const xAOD::Vertex* vertex,
                 const xAOD::VertexContainer* vertColl, const EventContext& ctx
                 ) const;
 
  //protected:
  private:
    SG::ReadHandleKey<xAOD::TrackParticleContainer> m_trackParticleKey { this, "TrackParticleCollection", "InDetTrackParticles",
                                                                         "key for retrieval of TrackParticles" };
 
    ToolHandle < Trk::IVertexFitter > m_iVertexFitter;
    ToolHandle < Trk::IVertexFitter > m_iVKVertexFitter;
    ToolHandle < Trk::IVertexFitter > m_iKshortFitter;
    ToolHandle < Trk::IVertexFitter > m_iLambdaFitter;
    ToolHandle < Trk::IVertexFitter > m_iLambdabarFitter;
    ToolHandle < Trk::IVertexFitter > m_iGammaFitter;
    ToolHandle < Trk::V0Tools > m_V0Tools;
    ToolHandle < Reco::ITrackToVertex > m_trackToVertexTool;
    ToolHandle < Trk::ITrackSelectorTool > m_trkSelector;
    ToolHandle < InDet::VertexPointEstimator > m_vertexEstimator;
    ToolHandle < Trk::IExtrapolator > m_extrapolator;
 
    const HepPDT::ParticleDataTable *m_particleDataTable;
 
    bool          m_doSimpleV0;               
    bool          m_useorigin;                
    bool          m_samesign;                 
    bool          m_pv;                       
    bool          m_use_vertColl;             
    bool          m_useTRTplusTRT;            
    bool          m_useTRTplusSi;             
    bool          m_useV0Fitter;              
    int           m_masses;                   
    double        m_masspi;                   
    double        m_massp;                    
    double        m_masse;                    
    double        m_massK0S;                  
    double        m_massLambda;               
    double        m_ptTRT;                    
    double        m_maxsxy;                   
    double        m_uksmin;                   
    double        m_uksmax;                   
    double        m_ulamin;                   
    double        m_ulamax;                   
    double        m_ksmin;                    
    double        m_ksmax;                    
    double        m_lamin;                    
    double        m_lamax;                    
    double        m_errmass;                  
    double        m_minVertProb;              
    double        m_minConstrVertProb;        
    double        m_d0_cut;                   
    double        m_vert_lxy_sig;             
    double        m_vert_lxy_cut;             
    double        m_vert_a0xy_cut;            
    double        m_vert_a0z_cut;             
 
    mutable std::atomic<unsigned int>  m_events_processed{};
    mutable std::atomic<unsigned int>  m_V0s_stored{};
    mutable std::atomic<unsigned int>  m_Kshort_stored{};
    mutable std::atomic<unsigned int>  m_Lambda_stored{};
    mutable std::atomic<unsigned int>  m_Lambdabar_stored{};
    mutable std::atomic<unsigned int>  m_Gamma_stored{};
 
 
    void SGError(const std::string& errService) const;
 
    static double invariantMass(const Trk::TrackParameters* per1, const Trk::TrackParameters* per2, double m1, double m2) ;
 
    bool doFit(const xAOD::TrackParticle* track1, const xAOD::TrackParticle* track2, Amg::Vector3D &startingPoint, const EventContext& ctx) const;
 
    bool d0Pass(const xAOD::TrackParticle* track1, const xAOD::TrackParticle* track2, const xAOD::VertexContainer * vertColl, const EventContext& ctx) const;
    bool d0Pass(const xAOD::TrackParticle* track1, const xAOD::TrackParticle* track2, const xAOD::Vertex * vertex, const EventContext& ctx) const;
    bool d0Pass(const xAOD::TrackParticle* track1, const xAOD::TrackParticle* track2, const Amg::Vector3D& vertex, const EventContext& ctx) const;
 
    bool pointAtVertex(const xAOD::Vertex* v0, const xAOD::Vertex* PV) const;
    bool pointAtVertexColl(xAOD::Vertex* v0, const xAOD::VertexContainer * vertColl) const;
 
    bool doMassFit(xAOD::Vertex* vxCandidate, int pdgID) const;
 
    xAOD::Vertex* massFit(int pdgID, const std::vector<const xAOD::TrackParticle*> &pairV0, const Amg::Vector3D &vertex) const;
 
    const Trk::TrkV0VertexFitter* m_concreteVertexFitter = nullptr;
 
    SG::ReadHandleKey<xAOD::VertexContainer> m_vertexKey { this, "VertexContainer", "PrimaryVertices",
                                                       "primary vertex container" };
    SG::WriteDecorHandleKey<xAOD::VertexContainer> m_v0LinksDecorkeyks;
    SG::WriteDecorHandleKey<xAOD::VertexContainer> m_v0LinksDecorkeylb;
    SG::WriteDecorHandleKey<xAOD::VertexContainer> m_v0LinksDecorkeylbb;
    SG::WriteDecorHandleKey<xAOD::VertexContainer> m_v0_ksLinksDecorkey;
    SG::WriteDecorHandleKey<xAOD::VertexContainer> m_v0_laLinksDecorkey;
    SG::WriteDecorHandleKey<xAOD::VertexContainer> m_v0_lbLinksDecorkey;
 
    SG::WriteDecorHandleKey<xAOD::VertexContainer> m_mDecor_gfit;
    SG::WriteDecorHandleKey<xAOD::VertexContainer> m_mDecor_gmass;
    SG::WriteDecorHandleKey<xAOD::VertexContainer> m_mDecor_gmasserr;
    SG::WriteDecorHandleKey<xAOD::VertexContainer> m_mDecor_gprob;
 
    SG::ReadHandleKey<xAOD::EventInfo> m_eventInfo_key{this, "EventInfo", "EventInfo", "Input event information"};
    SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
    SG::ReadDecorHandleKeyArray<xAOD::EventInfo> m_beamSpotDecoKey{this, "BeamSpotDecoKeys" ,{}, "Add the scheduler dependencies on the beamspot information"};
    Gaudi::Property<bool>       m_useBeamSpotCond { this, "UseBeamSpotCond", false };
    // V0 candidate output container name (same calling alg)
    Gaudi::Property<std::string>       m_v0Key { this, "V0ContainerName", "V0Candidates", "V0 container name (same calling alg)" };
    Gaudi::Property<std::string>       m_ksKey { this, "KshortContainerName", "KshortCandidates", "Ks container name (same calling alg)" };
    Gaudi::Property<std::string>       m_laKey { this, "LambdaContainerName", "LambdaCandidates",
                                                              "Lambda container name (same calling alg)" };
    Gaudi::Property<std::string>       m_lbKey { this, "LambdabarContainerName", "LambdabarCandidates", 
                                                              "Lambdabar container name (same calling alg)" };
    Gaudi::Property<int>       m_maxPV { this, "MaxPV", 999999 };
    SG::ReadHandleKeyArray<xAOD::TrackParticleContainer> m_RelinkContainers{this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" };
    ElementLink<xAOD::TrackParticleContainer> makeLink(const xAOD::TrackParticle*, const std::vector<const xAOD::TrackParticleContainer*>&) const;
 
  };
 
}//end of namespace InDet
 
#endif