MuonMatch.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
#ifndef MUIDEVENT_MUONMATCH_H
# define MUIDEVENT_MUONMATCH_H
 
#include "MuidEvent/FieldIntegral.h"
#include "MuidEvent/ScatteringAngleSignificance.h"
 
namespace Trk
{
    class RecVertex;
    class Track;
}
 
namespace Rec
{
class TrackParticle;
 
class MuonMatch
{
public:
    enum MatchType
    {
    Tight       = 0,
 
    Inner       = 1,
 
    Outer       = 2,
 
    Simple      = 3,
 
    Loose       = 4,
 
    Vertex      = 5,
 
    Unmatched   = 6,
 
    NumberOfMuonMatchTypes  = 7
    };
    
    // copy constructor
    MuonMatch (const MuonMatch&);
    
    // combined track constructor
    MuonMatch (const Trk::Track*        combinedTrack,
           const Trk::Track*        extrapolatedTrack,
           const Trk::Track*        indetTrack,
           const Trk::Track*        spectrometerTrack,
           const FieldIntegral&         fieldIntegral           = FieldIntegral(),
           double               innerMatchChi2          = 999999.,
           int              innerMatchDoF           = 0,
           double               innerMatchProb          = 0.,
           double               momentumBalanceSignificance = 0.,
           double               outerMatchChi2          = 999999.,
           int              outerMatchDoF           = 0,
           double               outerMatchProb          = 0.,
           const ScatteringAngleSignificance&   scatAngleSignificance = ScatteringAngleSignificance());
 
    // constructor for vertex associated track
    MuonMatch (const Trk::Track*        combinedTrack,
           const TrackParticle*     indetParticle,
           const TrackParticle*     spectrometerParticle,
           const Trk::RecVertex*        vertex,
           const FieldIntegral&         fieldIntegral = FieldIntegral(),
           const ScatteringAngleSignificance&   scatAngleSignificance = ScatteringAngleSignificance());
       
    // "copy" constructor with steal of combined track 
    MuonMatch (MuonMatch&);
 
    // "assign" operator with steal of combined track 
    MuonMatch& operator=(MuonMatch&);
    
    // destructor
    virtual ~MuonMatch();
 
    // EDM accessors
    const Trk::Track*       combinedTrack (void) const;
    const Trk::Track*       extrapolatedRefit (void) const;
    const Trk::Track*       extrapolatedTrack (void) const;
    const TrackParticle*    indetParticle (void) const;
    const Trk::Track*       indetTrack (void) const;
    const TrackParticle*    spectrometerParticle (void) const;
    const Trk::Track*       spectrometerTrack (void) const;
    const Trk::RecVertex*   vertex (void) const;
 
    // set and steal EDM methods
    void            extrapolatedRefit (const Trk::Track* refittedTrack);
    void            extrapolatedTrack (const Trk::Track* extrapolatedTrack);
    
    // other attributes (set and accessor methods)
    bool            bestMatch (void) const;
    void            bestMatch (bool);
    void            fieldIntegral (const FieldIntegral& value);
    const FieldIntegral&    fieldIntegral (void) const;
    void            innerMatch (double matchChi2, int matchDoF, double matchProb);
    double          innerMatchChi2 (void) const;
    int             innerMatchDoF (void) const;
    double          innerMatchProb (void) const;
    bool            isType (MatchType) const;
    MatchType           matchType (void) const;
    void            matchType (MatchType);
    void            momentumBalanceSignificance (double value);
    double          momentumBalanceSignificance (void) const;
    void            outerMatch (double matchChi2, int matchDoF, double matchProb);
    double          outerMatchChi2 (void) const;
    int             outerMatchDoF (void) const;
    double          outerMatchProb (void) const;
    void            scatteringAngleSignificance (const ScatteringAngleSignificance& value);
    const ScatteringAngleSignificance& scatteringAngleSignificance (void) const;
     
    // deprecated
    bool            looseMatch (void) const;
    void            looseMatch (bool);
    bool            simpleMatch (void) const;
    void            simpleMatch (bool);
       
protected:
    const Trk::Track*           m_combinedTrack;
    const Trk::Track*           m_extrapolatedRefit;
    const Trk::Track*           m_extrapolatedTrack;
    const TrackParticle*        m_indetParticle;
    const Trk::Track*           m_indetTrack;
    const TrackParticle*        m_spectrometerParticle;
    const Trk::Track*           m_spectrometerTrack;
    const Trk::RecVertex*       m_vertex;
    bool                m_bestMatch;
    FieldIntegral           m_fieldIntegral;
    double              m_innerMatchChi2;
    int                 m_innerMatchDoF;
    double              m_innerMatchProb;
    MatchType               m_matchType;
    double              m_momentumBalanceSignificance;
    double              m_outerMatchChi2;
    int                 m_outerMatchDoF;
    double              m_outerMatchProb;
    ScatteringAngleSignificance     m_scatteringAngleSignificance;
 
    // deprecated
    bool                m_looseMatch;
    bool                m_simpleMatch;
    
};
 
//<<<<<< INLINE MEMBER FUNCTIONS                                        >>>>>>
 
inline const Trk::Track*
MuonMatch::combinedTrack (void) const
{ return m_combinedTrack; }
 
inline const Trk::Track*
MuonMatch::extrapolatedRefit (void) const
{ return m_extrapolatedRefit; }
 
inline const Trk::Track*
MuonMatch::extrapolatedTrack (void) const
{ return m_extrapolatedTrack; }
 
inline const TrackParticle*
MuonMatch::indetParticle (void) const
{ return m_indetParticle; }
 
inline const Trk::Track*
MuonMatch::indetTrack (void) const
{ return m_indetTrack; }
 
inline const TrackParticle*
MuonMatch::spectrometerParticle (void) const
{ return m_spectrometerParticle; }
 
inline const Trk::Track*
MuonMatch::spectrometerTrack (void) const
{ return m_spectrometerTrack; }
 
inline const Trk::RecVertex*
MuonMatch::vertex (void) const
{ return m_vertex; }
 
inline bool
MuonMatch::bestMatch (void) const
{ return m_bestMatch; }
 
inline void
MuonMatch::bestMatch (bool value)
{ m_bestMatch = value; }
 
inline const FieldIntegral&
MuonMatch::fieldIntegral (void) const
{ return m_fieldIntegral; } 
 
inline void
MuonMatch::innerMatch(double matchChi2, int matchDoF, double matchProb) 
{
    m_innerMatchChi2    = matchChi2;
    m_innerMatchDoF = matchDoF;
    m_innerMatchProb    = matchProb;
}   
 
inline double
MuonMatch::innerMatchChi2 (void) const
{ return m_innerMatchChi2; }    
 
inline int
MuonMatch::innerMatchDoF (void) const
{ return m_innerMatchDoF; } 
 
inline double
MuonMatch::innerMatchProb (void) const
{ return m_innerMatchProb; }    
 
inline bool
MuonMatch::isType (MuonMatch::MatchType type) const
{ return (m_matchType == type); }
    
inline MuonMatch::MatchType
MuonMatch::matchType (void) const
{ return m_matchType; } 
 
inline double
MuonMatch::momentumBalanceSignificance (void) const
{ return m_momentumBalanceSignificance; }
 
inline void
MuonMatch::outerMatch(double matchChi2, int matchDoF, double matchProb) 
{
    m_outerMatchChi2    = matchChi2;
    m_outerMatchDoF = matchDoF;
    m_outerMatchProb    = matchProb;
}   
 
inline double
MuonMatch::outerMatchChi2 (void) const
{ return m_outerMatchChi2; }    
 
inline int
MuonMatch::outerMatchDoF (void) const
{ return m_outerMatchDoF; } 
 
inline double
MuonMatch::outerMatchProb (void) const
{ return m_outerMatchProb; }    
 
inline const ScatteringAngleSignificance&
MuonMatch::scatteringAngleSignificance (void) const
{ return m_scatteringAngleSignificance; }
 
inline bool
MuonMatch::looseMatch (void) const
{ return m_looseMatch; }
 
inline void
MuonMatch::looseMatch (bool value)
{ m_looseMatch = value; }
 
inline bool
MuonMatch::simpleMatch (void) const
{ return m_simpleMatch; }
 
inline void
MuonMatch::simpleMatch (bool value)
{ m_simpleMatch = value; }
 
}   // end of namespace
 
#endif // MUIDEVENT_MUONMATCH_H