Reconstruction/MuonIdentification/muonEvent/muonEvent/Muon.h

Go to the documentation of this file.

// dear emacs, this is -*- C++ -*-
 
/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONEVENT_MUON_H
#define MUONEVENT_MUON_H 1
/*****************************************************************************
Name    : Muon.h - Adapted from the previous CombinedMuon.h
Package : offline/Reconstruction/MuonIdentification/muonEvent
Author  : Ketevi A. Assamagan
*****************************************************************************/
 
#include "ParticleEvent/ParticleImpl.h"
#include "CLHEP/Vector/LorentzVector.h"
#include "FourMom/Lib/P4ImplIPtCotThPhiM.h"
 
#include "CaloEvent/CaloClusterContainer.h"
#include "Particle/TrackParticleContainer.h"
#include "TrkSegment/SegmentCollection.h"
#include "muonEvent/MuonCaloEnergyContainer.h"
#include "muonEvent/MuonParamDefs.h"
#include "AthLinks/ElementLink.h"
#include "AthLinks/ElementLinkVector.h"
 
#include "muonEvent/MuonQualityWord.h"
 
#include <inttypes.h>
 
namespace Analysis {
  typedef NavigableTerminalNode MuonNavigation;
 
class Muon : public ParticleImpl<
  ::Analysis::MuonNavigation,
  ::P4ImplIPtCotThPhiM
  >
{
 
  // Public typedefs:
 public:
 
  // for readability and lazy people
  typedef ParticleImpl< ::Analysis::MuonNavigation,
                        ::P4ImplIPtCotThPhiM
    > MuonImpl_t;
  typedef MuonImpl_t::navigable_type navigable_type;
  typedef MuonImpl_t::momentum_type  momentum_type;
  typedef MuonImpl_t::particle_type  particle_type;
 
 public:
 
  Muon( );
 
  Muon( MuonParameters::Author author );
 
  Muon( MuonParameters::Author author,
        const Rec::TrackParticle* inDetTP, const Rec::TrackParticle* extrapTP,
        const Rec::TrackParticle* combTP, const bool isExtrapolatedToVertex=true);
 
 
  Muon( MuonParameters::Author author, const Rec::TrackParticle* inDetTP,
        const Trk::SegmentCollection* segmentContainer,
        const std::vector<const Trk::Segment*>& muonSegments);
 
  Muon(MuonParameters::Author author,
       const Rec::TrackParticle* extrapTP, const bool isExtrapolatedToVertex=false);
 
  Muon( const Muon& rhs );
 
  Muon& operator=( const Muon& rhs );
 
  ~Muon();
 
  virtual void fillToken( INavigationToken & thisToken ) const;
  virtual void fillToken( INavigationToken & thisToken, const std::any& ) const;
 
  MuonParameters::Author author() const { return m_author; }
 
  uint16_t allAuthors() const { return m_allAuthors; }
 
  bool isAuthor ( const unsigned int author ) const;
 
  bool isAuthor ( const MuonParameters::Author author ) const;
 
  void set_author (MuonParameters::Author author) { m_author = author;}
 
  void set_allAuthors ( const uint16_t allAuthors ) { m_allAuthors = allAuthors; }
 
  bool add_author ( MuonParameters::Author author );
 
  void add_authors ( const uint16_t authors ) { m_allAuthors |= authors; }
 
  bool isCombinedMuon() const;
 
  bool isStandAloneMuon() const;
 
  bool isSegmentTaggedMuon() const;
 
  bool isCaloMuonId() const;
 
  bool isSiliconAssociatedForwardMuon() const;
 
  bool alsoFoundByLowPt () const { return m_isAlsoFoundByLowPt; }
 
  bool alsoFoundByCaloMuonId () const { return m_isAlsoFoundByCaloMuonId; }
 
  unsigned short caloMuonAlsoFoundByMuonReco() const { return m_caloMuonAlsoFoundByMuonReco; }
 
  void set_isAlsoFoundByLowPt(const bool isAlsoSeenByLowPt) {
    (isAlsoSeenByLowPt) ? m_isAlsoFoundByLowPt=true : m_isAlsoFoundByLowPt=false;
  }
 
  void set_isAlsoFoundByCaloMuonId(const bool isAlsoSeenByCaloMuonId) {
    (isAlsoSeenByCaloMuonId) ? m_isAlsoFoundByCaloMuonId=true : m_isAlsoFoundByCaloMuonId=false; }
 
  void set_caloMuonAlsoFoundByMuonReco(const unsigned short isAlsoFoundByMuonReco) {
    m_caloMuonAlsoFoundByMuonReco=isAlsoFoundByMuonReco;
  }
 
  const Rec::TrackParticle * track() const;
 
  double parameter( MuonParameters::ParamDef x) const;
  const std::vector< std::pair<MuonParameters::ParamDef,float> > & parameter() const { return m_parameters; }
 
  double matchChi2() const {return m_matchChi2;}
 
  double matchChi2OverDoF() const {
     int dof = this->matchNumberDoF();
     if (dof > 0) return (this->matchChi2()/dof);
     else return 0;
  }
 
  int matchNumberDoF() const {return m_matchNumberDoF;}
 
  int outerMatchNumberDoF() const {return m_outerMatchNumberDoF;}
 
  double fitChi2() const {
    const Rec::TrackParticle * theTrack = track();
    if ( theTrack ) return theTrack->fitQuality()->chiSquared();
    else return -1.0;
  }
 
  int fitNumberDoF() const {
    const Rec::TrackParticle * theTrack = track();
    if ( theTrack ) return theTrack->fitQuality()->numberDoF();
    else return 0;
  }
 
  double fitChi2OverDoF() const {
    int dof = this->fitNumberDoF();
    if (dof > 0) return (fitChi2() / dof);
    else return 0.0;
  }
 
  const Trk::FitQuality* outerMatchChi2() const{
    if (m_outerMatchNumberDoF>0) return &m_transientOuterMatchChi2;
    else return NULL;
  }
 
  std::pair<double,double> energyLoss() const;
 
  const CaloEnergy* caloEnergyLoss() const { return (m_caloEnergyLoss.isValid() ? *m_caloEnergyLoss : 0); }
 
  bool bestMatch () const { return m_bestMatch; }
 
  bool isCorrected () const { return m_isCorrected; }
 
//  bool isLowPtReconstructedMuon() const {
//    bool accept = false;
//    if ( m_hasInDetTrackParticle && !this->hasInDetTrackParticle() )
//       accept = this->isLowPt() && !this->bestMatch();
//    /** this is the case of the AOD */
//   else
//        accept = this->isLowPt() && this->hasInDetTrackParticle() && !this->bestMatch();
//    return accept;
//  }
 
  bool hasCombinedMuon() const                  {return hasCombinedMuonTrackParticle();}
  bool hasInDetTrackParticle() const            {return m_inDetTrackParticle.isValid();}
  bool hasMuonExtrapolatedTrackParticle() const {return m_muonExtrapolatedTrackParticle.isValid();}
  bool hasInnerExtrapolatedTrackParticle() const {return m_innerExtrapolatedTrackParticle.isValid();}
  bool hasCombinedMuonTrackParticle() const     {return m_combinedMuonTrackParticle.isValid();}
  bool hasStatCombinedMuonTrackParticle() const {return m_statCombinedMuonTrackParticle.isValid();}
 
  bool hasCluster() const { return m_cluster.isValid();}
 
  bool hasGlobalMuonTrackFit() const;
 
//  bool isHighPt() const;
 
 // bool isLowPt() const;
 
  const Rec::TrackParticle* inDetTrackParticle() const {
    return ( (this->hasInDetTrackParticle()) ? *m_inDetTrackParticle : 0); }
 
  const Rec::TrackParticle* muonSpectrometerTrackParticle() const {
    return ( (m_muonSpectrometerTrackParticle.isValid()) ? *m_muonSpectrometerTrackParticle : 0); }
 
  const Rec::TrackParticle* muonExtrapolatedTrackParticle() const {
    return ( (this->hasMuonExtrapolatedTrackParticle()) ? *m_muonExtrapolatedTrackParticle : 0); }
 
  const Rec::TrackParticle* innerExtrapolatedTrackParticle() const {
    return ( (this->hasInnerExtrapolatedTrackParticle()) ? *m_innerExtrapolatedTrackParticle : 0); }
 
  const Rec::TrackParticle* combinedMuonTrackParticle() const {
    return ( (this->hasCombinedMuonTrackParticle()) ? *m_combinedMuonTrackParticle : 0); }
 
  const Rec::TrackParticle* statCombinedMuonTrackParticle() const {
    return ( (this->hasStatCombinedMuonTrackParticle()) ? *m_statCombinedMuonTrackParticle : 0); }
 
  const ElementLinkVector<Trk::SegmentCollection>& muonSegmentLink() const { return m_muonSegments; }
 
  void setMuonSegmentLink (const ElementLinkVector<Trk::SegmentCollection>& l)
  { m_muonSegments = l; }
 
  const ElementLink<Trk::SegmentCollection> muonSegmentLink(const unsigned int i, bool& validLink) const;
 
  const ElementLink<Rec::TrackParticleContainer>& inDetTrackLink() const { return m_inDetTrackParticle; }
 
  void setInDetTrackLink(const ElementLink<Rec::TrackParticleContainer>& l)
  { m_inDetTrackParticle = l; }
 
  const ElementLink<Rec::TrackParticleContainer>& muonExtrapTrackLink() const { return m_muonExtrapolatedTrackParticle; }
 
  void setMuonExtrapTrackLink (const ElementLink<Rec::TrackParticleContainer>& l,
                               bool isValid)
  {
    m_muonExtrapolatedTrackParticle = l;
    m_hasMuonExtrapolatedTrackParticle = isValid;
  }
 
  bool hasMuonExtrapolatedTrackParticleFlag() const
  { return m_hasMuonExtrapolatedTrackParticle; }
 
  const ElementLink<Rec::TrackParticleContainer>& innerExtrapTrackLink() const { return m_innerExtrapolatedTrackParticle; }
 
  void setInnerExtrapTrackLink (const ElementLink<Rec::TrackParticleContainer>& l)
  { m_innerExtrapolatedTrackParticle = l; }
 
  const ElementLink<Rec::TrackParticleContainer>& combinedTrackLink() const { return m_combinedMuonTrackParticle; }
 
  void setCombinedTrackLink (const ElementLink<Rec::TrackParticleContainer>& l,
                             bool isValid)
  {
    m_combinedMuonTrackParticle = l;
    m_hasCombinedMuonTrackParticle = isValid;
  }
 
  bool hasCombinedMuonTrackParticleFlag() const
  { return m_hasCombinedMuonTrackParticle; }
 
  const ElementLink<Rec::TrackParticleContainer>& statCombinedTrackLink() const { return m_statCombinedMuonTrackParticle; }
 
  void setStatCombinedTrackLink (const ElementLink<Rec::TrackParticleContainer>& l)
  { m_statCombinedMuonTrackParticle = l; }
 
  const ElementLink<Rec::TrackParticleContainer>& muonSpectrometerTrackLink() const { return m_muonSpectrometerTrackParticle; }
 
  void setMuonSpectrometerTrackLink (const ElementLink<Rec::TrackParticleContainer>& l)
  { m_muonSpectrometerTrackParticle = l; }
 
  /*8 Access to the smart pointer to the calo  cluster associated to the muon */
  const ElementLink<CaloClusterContainer>& clusterLink() const { return m_cluster; }
 
  void setClusterLink (const ElementLink<CaloClusterContainer>& l)
  { m_cluster = l; }
 
  const ElementLink<MuonCaloEnergyContainer>& caloEnergyLink() const { return m_caloEnergyLoss; }
 
  void setCaloEnergyLink (const ElementLink<MuonCaloEnergyContainer>& l)
  { m_caloEnergyLoss = l; }
 
  const CaloCluster* cluster() const { return ((this->hasCluster()) ? *m_cluster : 0); }
 
  int numberOfInnermostPixelLayerHits() const;
  int numberOfPixelHits() const;
  int numberOfSCTHits() const;
  int numberOfTRTHits() const;
  int numberOfTRTHighThresholdHits() const;
  int numberOfInnermostPixelLayerSharedHits() const;
  int numberOfPixelSharedHits() const;
  int numberOfPixelHoles() const;
  int numberOfSCTSharedHits() const;
  int numberOfSCTHoles() const;
  int numberOfTRTOutliers() const;
  int numberOfTRTHighThresholdOutliers() const;
 
  int numberOfMDTHits() const;
  int numberOfMDTHoles() const;
  int numberOfCSCEtaHits() const;
  int numberOfCSCEtaHoles() const;
  int numberOfCSCPhiHits() const;
  int numberOfCSCPhiHoles() const;
  int numberOfRPCEtaHits() const;
  int numberOfRPCEtaHoles() const;
  int numberOfRPCPhiHits() const;
  int numberOfRPCPhiHoles() const;
  int numberOfTGCEtaHits() const;
  int numberOfTGCEtaHoles() const;
  int numberOfTGCPhiHits() const;
  int numberOfTGCPhiHoles() const;
 
  int numberOfGangedPixels() const;
  int numberOfOutliersOnTrack() const;
  int numberOfTrackSummaryTypes(unsigned int type=0) const;
 
  // get d0 and z0 with respect to primary vertex
  // KC: These methods were taking out of the TrackParticle
  //  const double z0wrtPrimVtx() const;
  //  const double d0wrtPrimVtx() const;
 
  const std::vector<int>& associatedEtaDigits() const { return m_associatedEtaDigits; }
  const std::vector<int>& associatedPhiDigits() const { return m_associatedPhiDigits; }
  const std::vector<int>& segmentEtaDigits() const { return m_associatedEtaDigits; }
  const std::vector<int>& segmentPhiDigits() const { return m_associatedPhiDigits; }
 
  float spectrometerFieldIntegral() const
  { return this->parameter(MuonParameters::spectrometerFieldIntegral); }
 
  float scatteringCurvatureSignificance() const
  { return this->parameter(MuonParameters::scatteringCurvatureSignificance); }
 
  float scatteringNeighbourSignificance() const
  { return this->parameter(MuonParameters::scatteringNeighbourSignificance); }
 
  float momentumBalanceSignificance() const
  {return this->parameter(MuonParameters::momentumBalanceSignificance); }
 
  float segmentDeltaEta() const { return this->parameter(MuonParameters::segmentDeltaEta); }
  float segmentDeltaPhi() const { return this->parameter(MuonParameters::segmentDeltaPhi); }
  float segmentChi2OverDoF() const { return this->parameter(MuonParameters::segmentChi2OverDoF); }
  float annBarrel () const { return this->parameter(MuonParameters::annBarrel); }
  float annEndCap () const { return this->parameter(MuonParameters::annEndCap); }
  float innAngle () const { return this->parameter(MuonParameters::innAngle); }
  float midAngle () const { return this->parameter(MuonParameters::midAngle); }
  float t0() const { return this->parameter(MuonParameters::t0); }
  float beta() const { return this->parameter(MuonParameters::beta); }
 
  const Trk::Segment * muonSegment(unsigned int i) const {
     if ( m_muonSegments.size() <= i ) return 0;
     else if ( m_muonSegments[i].isValid() ) return *(m_muonSegments[i]);
     else return 0; }
 
  unsigned int numberOfSegments() const { return m_muonSegments.size(); }
 
  const Trk::Track* inDetTrkTrack() const {
    return ((this->hasInDetTrackParticle()) ? (*m_inDetTrackParticle)->originalTrack() : 0); }
  const Trk::Track* muonSpectrometerTrkTrack() const {
    return ((m_muonSpectrometerTrackParticle.isValid()) ? (*m_muonSpectrometerTrackParticle)->originalTrack() : 0); }
  const Trk::Track* muonExtrapolatedTrkTrack() const {
    return ((this->hasMuonExtrapolatedTrackParticle()) ? (*m_muonExtrapolatedTrackParticle)->originalTrack() : 0); }
  const Trk::Track* innerExtrapolatedTrkTrack() const {
    return ((this->hasInnerExtrapolatedTrackParticle()) ? (*m_innerExtrapolatedTrackParticle)->originalTrack() : 0); }
  const Trk::Track* combinedMuonTrkTrack() const {
    return ((this->hasCombinedMuonTrackParticle()) ? (*m_combinedMuonTrackParticle)->originalTrack() : 0); }
 
  const MuonQualityWord & isMuon () const {
    return m_isMuonBits;
  }
 
  bool isLoose () const {
    return m_isMuonBits.isLoose();
  }  
 
  bool isMedium () const {
    return m_isMuonBits.isMedium();
  }
 
  bool isTight () const {
    return m_isMuonBits.isTight();
  }
 
  float isMuonLikelihood() const { return m_isMuonLikelihood; }
 
  // set methods
 
  void set_parameter(MuonParameters::ParamDef index, double value, bool overwrite=false);
 
  void set_energyLoss ( const CaloEnergy* caloEnergy ) { m_caloEnergyLoss.setElement(caloEnergy); }
  void set_energyLossContainer ( const MuonCaloEnergyContainer* cont ) { m_caloEnergyLoss.setStorableObject(*cont); }
  void set_energyLoss ( const MuonCaloEnergyContainer* cont, const CaloEnergy* caloEnergy );
 
  void set_matchChi2(float x)     {m_matchChi2 = x;}
  void set_matchNumberDoF(int x)  {m_matchNumberDoF = x;}
  void set_outerMatchChi2(double x, int ndof);
 
  void set_bestMatch( bool best) { m_bestMatch = best; }
 
  void set_isCorrected ( bool corrected ) { m_isCorrected=corrected; }
 
  void set_cluster( const CaloClusterContainer* cont, const CaloCluster* cluster ) {
    m_cluster.toContainedElement( *cont, cluster);
  }
  void set_cluster( const CaloCluster* cluster) {
     m_cluster.setElement(cluster);
  }
  void set_cluster( const ElementLink<CaloClusterContainer>& cluster) {
     m_cluster = cluster;
  }
  void set_clusterContainer(const CaloClusterContainer * clusterContainer) {
     m_cluster.setStorableObject(*clusterContainer);
  }
 
  void set_inDetTrackParticle(const Rec::TrackParticleContainer*, const Rec::TrackParticle* );
  void set_inDetTrackParticle(const Rec::TrackParticle* );
 
  void set_muonSpectrometerTrackParticle(const Rec::TrackParticleContainer*, const Rec::TrackParticle*);
 
  void set_muonExtrapolatedTrackParticle(const Rec::TrackParticleContainer*, const Rec::TrackParticle*);
  void set_muonExtrapolatedTrackParticle(const Rec::TrackParticle* );
 
  void set_innerExtrapolatedTrackParticle(const Rec::TrackParticleContainer*, const Rec::TrackParticle*);
  void set_innerExtrapolatedTrackParticle(const Rec::TrackParticle* );
 
  void set_combinedMuonTrackParticle(const Rec::TrackParticleContainer*, const Rec::TrackParticle* );
  void set_combinedMuonTrackParticle(const Rec::TrackParticle* );
  void set_statCombinedMuonTrackParticle(const Rec::TrackParticleContainer*,
                     const Rec::TrackParticle* );
 
  void set_muonSegments(const Trk::SegmentCollection*, const std::vector<const Trk::Segment*>& );
  void addSegment ( const Trk::SegmentCollection*, const Trk::Segment* );
 
  void set_inDetTrackParticleContainer(const Rec::TrackParticleContainer * inDetTPContainer) {
     m_inDetTrackParticle.setStorableObject(*inDetTPContainer);
  }
  void set_muonExtrapolatedTrackParticleContainer(const Rec::TrackParticleContainer *
                                                  muonExtrapolatedTPContainer) {
     m_muonExtrapolatedTrackParticle.setStorableObject(*muonExtrapolatedTPContainer);
     m_hasMuonExtrapolatedTrackParticle = m_muonExtrapolatedTrackParticle.isValid();
  }
  void set_innerExtrapolatedTrackParticleContainer(const Rec::TrackParticleContainer *
                                                   innerExtrapolatedTPContainer) {
     m_innerExtrapolatedTrackParticle.setStorableObject(*innerExtrapolatedTPContainer);
  }
  void set_combinedMuonTrackParticleContainer(const Rec::TrackParticleContainer * combinedMuonTPContainer) {
     m_combinedMuonTrackParticle.setStorableObject(*combinedMuonTPContainer);
     m_hasCombinedMuonTrackParticle = m_combinedMuonTrackParticle.isValid();
  }
 
  void set_statCombinedMuonTrackParticleContainer(const Rec::TrackParticleContainer * combinedMuonTPContainer) {
     m_statCombinedMuonTrackParticle.setStorableObject(*combinedMuonTPContainer);
  }
 
  void set_numberOfAssociatedEtaDigits(int nMDT, int nCSC, int nRPC, int nTGC);
  void set_numberOfAssociatedPhiDigits(int nMDT, int nCSC, int nRPC, int nTGC);
  void set_numberOfAssociatedEtaDigits(const std::vector<int>& associated_digits);
  void set_numberOfAssociatedPhiDigits(const std::vector<int>& associated_digits);
 
  void set_numberOfSegmentEtaDigits(int nMDT, int nCSC, int nRPC, int nTGC);
  void set_numberOfSegmentPhiDigits(int nMDT, int nCSC, int nRPC, int nTGC);
  void set_numberOfSegmentEtaDigits(const std::vector<int>& associated_digits);
  void set_numberOfSegmentPhiDigits(const std::vector<int>& associated_digits);
 
  void set_spectrometerFieldIntegral (const float field) 
  { this->set_parameter(MuonParameters::spectrometerFieldIntegral,field); }
 
  void set_scatteringCurvatureSignificance (const float significance) 
  { this->set_parameter(MuonParameters::scatteringCurvatureSignificance,significance); }
 
  void set_scatteringNeighbourSignificance (const float significance) 
  { this->set_parameter(MuonParameters::scatteringNeighbourSignificance,significance); }
 
  void set_momentumBalanceSignificance(const float significance)
  { this->set_parameter(MuonParameters::momentumBalanceSignificance,significance); }
 
  void set_segmentDeltaEta (const float  deltaEta) { this->set_parameter(MuonParameters::segmentDeltaEta,deltaEta); }
  void set_segmentDeltaPhi (const float  deltaPhi) {  this->set_parameter(MuonParameters::segmentDeltaPhi,deltaPhi); }
  void set_segmentChi2OverDoF (const float chi2) { this->set_parameter(MuonParameters::segmentChi2OverDoF,chi2); }
 
  void set_annBarrel (const float annB) {  this->set_parameter(MuonParameters::annBarrel,annB); }
  void set_annEndCap (const float annE) {  this->set_parameter(MuonParameters::annEndCap,annE); }
  void set_innAngle  (const float innA) {  this->set_parameter(MuonParameters::innAngle,innA); }
  void set_midAngle  (const float midA) {  this->set_parameter(MuonParameters::midAngle,midA); }
 
 //-----------------------------------------------------------------
 // 4-mom modifiers
 //-----------------------------------------------------------------
 
 void setIPt( const double theIPt )
 { return this->momentumBase().setIPt(theIPt); }
 
 void setCotTh( const double theCotTh )
 { return this->momentumBase().setCotTh(theCotTh); }
 
 void setPhi( const double thePhi )
 { return this->momentumBase().setPhi(thePhi); }
 
 void setM( const double theM )
 { return this->momentumBase().setM(theM); }
 
 void copySegmentLinkVector( const ElementLinkVector<Trk::SegmentCollection>& segments );
 
 void set_isMuonBits ( const uint16_t isMuonBits ) { m_isMuonBits.set(isMuonBits); }
 void set_isMuonBits ( const MuonQualityWord& qWord ) { m_isMuonBits = qWord; }
 void set_isMuonLikelihood ( const float muonLikelihood ) { m_isMuonLikelihood = muonLikelihood; }
 
 private:
 
  MuonParameters::Author m_author;
 
  bool m_hasMuonExtrapolatedTrackParticle;
  bool m_hasCombinedMuonTrackParticle;
 
  /* chi2 of the track matching */
  float m_matchChi2;
  int m_matchNumberDoF;
  int m_outerMatchNumberDoF;
  Trk::FitQuality m_transientOuterMatchChi2;
  bool m_bestMatch;
 
  std::vector<int> m_associatedEtaDigits;
  std::vector<int> m_associatedPhiDigits;
  ElementLink<Rec::TrackParticleContainer> m_inDetTrackParticle;
  ElementLinkVector<Trk::SegmentCollection> m_muonSegments;
  ElementLink<Rec::TrackParticleContainer> m_muonExtrapolatedTrackParticle;
  ElementLink<Rec::TrackParticleContainer> m_innerExtrapolatedTrackParticle;
  ElementLink<Rec::TrackParticleContainer> m_combinedMuonTrackParticle;
  ElementLink<Rec::TrackParticleContainer> m_statCombinedMuonTrackParticle;
  ElementLink<CaloClusterContainer> m_cluster;
 
  ElementLink<Rec::TrackParticleContainer> m_muonSpectrometerTrackParticle;
 
  std::vector<std::pair<MuonParameters::ParamDef, float> > m_parameters;
 
  bool m_isAlsoFoundByLowPt;
 
  bool m_isAlsoFoundByCaloMuonId;
 
  ElementLink<MuonCaloEnergyContainer> m_caloEnergyLoss;
 
  unsigned short m_caloMuonAlsoFoundByMuonReco;
 
  bool m_isCorrected;
 
 
  uint16_t m_allAuthors;
 
  MuonQualityWord m_isMuonBits;
  float    m_isMuonLikelihood;
 
};
 
}
 
#endif // MUONEVENT_MUON_H