ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
MuonSelector Class Reference

#include <MuonSelector.h>

Inheritance diagram for MuonSelector:
Collaboration diagram for MuonSelector:

Public Member Functions

 MuonSelector ()
 
 ~MuonSelector ()
 
 MuonSelector (const MuonSelector &)=delete
 
MuonSelector & operator= (const MuonSelector &)=delete
 
bool passSelection (const xAOD::Muon *pxMuon)
 
void setDebug (bool debug)
 
virtual void Init ()
 
void doIsoSelection (bool doIso)
 
void doIPSelection (bool doIPsel)
 
void doMCPSelection (bool domcp)
 
virtual void finalize ()
 
void SetPtCut (double newvalue)
 
double GetPtCut ()
 
virtual bool Reco ()
 
void SetMuonQualityRequirement (std::string newname)
 
void SetCustomMuonSelectionTool (ToolHandle< CP::IMuonSelectionTool > mst)
 

Static Public Member Functions

template<class T >
static CLHEP::Hep3Vector calculateMomentum (const T *pP)
 
template<class T >
static float EvalInvMass (const T *pxP1, const T *pxP2, float fMass1, float fMass2=invalidAnswer)
 
template<class T >
static float EvalInvMass (const T *pxP1, const T *pxP2, const T *pxp3, const T *pxP4, float fMass1, float fMass2=-999.9, float fMass3=-999.9, float fMass4=invalidAnswer)
 
template<class T >
static float EvalDiMuInvMass (const T *pxP1, const T *pxP2)
 
template<class T >
static float EvalFourMuInvMass (const T *pxP1, const T *pxP2, const T *pxP3, const T *pxP4)
 
template<class T >
static float EvaluateAngle (const T *pxP1, const T *pxP2)
 
template<class T >
static float EvalPtDiff (const T *pxP1, const T *pxP2)
 
template<class T >
static float EvalPhiDiff (const T *pxP1, const T *pxP2)
 
template<class T >
static float EvalEtaDiff (const T *pxP1, const T *pxP2)
 
template<class T >
static float EvalPt (const T *pxP1, const T *pxP2)
 
template<class T >
static float EvalPhi (const T *pxP1, const T *pxP2)
 
template<class T >
static float EvalEta (const T *pxP1, const T *pxP2)
 
template<class T >
static float EvalCharge (const T *pxP1, const T *pxP2)
 
template<class T >
static float EvalTransverseMass (const T *pxP1, float fMETx, float fMETy, float fMass1, float fMass2=invalidAnswer)
 
template<class T >
static float EvalTransverseMass (const T *pxP1, float fMETx, float fMETy)
 
template<class T >
static float EvalTransverseMass (const T *pxP1, const T *pxP2, float fMETx, float fMETy, float fMass1, float fMass2=invalidAnswer)
 
template<class T >
static float EvalTransverseMass (const T *pxP1, const T *pxP2, float fMETx, float fMETy)
 

Public Attributes

ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
 

Static Public Attributes

static constexpr float invalidAnswer {-999.9f}
 

Protected Member Functions

virtual void BookHistograms ()
 

Protected Attributes

unsigned int m_uPassedEvents
 
std::map< unsigned int, TH1F * > m_x1DHistograms
 
std::map< unsigned int, TH2F * > m_x2DHistograms
 
std::map< unsigned int, TProfile * > m_x1DProfHistograms
 
std::map< unsigned int, TProfile2D * > m_x2DProfHistograms
 
std::string m_xSampleName
 

Private Types

enum  HISTOS_1D { NMDT, NCSC, ECONE, NUM_1HISTOS }
 
typedef EventAnalysis PARENT
 

Private Member Functions

bool passQualCuts ()
 
bool passPtCuts ()
 
bool passIsolCuts ()
 
bool passIPCuts ()
 
void Register ()
 

Private Attributes

unsigned int m_uNumInstances = 0U
 
MsgStream * m_msgStream
 
const xAOD::Muon * m_pxMuon
 
int m_requestedMuonQuality {}
 
double m_coneSize {}
 
unsigned char m_ucJMuon_Cut
 
double m_IsoCut
 
bool m_bCutOnCombKine
 
float m_fEtaCut
 
double m_combPtCut
 
float m_ptMSCut
 
float m_diffZCut
 
float m_diffPtCut
 
float m_pVZCut
 
float m_fIDPtCut
 
float m_fIDChiPerDofCut
 
int m_IDSiHitsCut
 
unsigned char m_ucID_PIXCut
 
unsigned char m_ucID_SCTCut
 
unsigned char m_ucID_TRTCut
 
bool m_doDebug
 
bool m_doQualSelection
 
bool m_doIsoSelection
 
bool m_doPtSelection
 
bool m_doIPSelection
 
bool m_doMCPSelection
 
bool m_bLock
 
unsigned int m_testedmuons {}
 
unsigned int m_passqual {}
 
unsigned int m_passiso {}
 
unsigned int m_passpt {}
 
unsigned int m_passip {}
 
unsigned int m_passmcp {}
 
unsigned int m_passall {}
 

Detailed Description

Definition at line 33 of file MuonSelector.h.

Member Typedef Documentation

◆ PARENT

typedef EventAnalysis MuonSelector::PARENT
private

Definition at line 64 of file MuonSelector.h.

Member Enumeration Documentation

◆ HISTOS_1D

enum MuonSelector::HISTOS_1D
private
Enumerator
NMDT 
NCSC 
ECONE 
NUM_1HISTOS 

Definition at line 128 of file MuonSelector.h.

129  {
130  NMDT, NCSC, ECONE,
131  NUM_1HISTOS
132  };

Constructor & Destructor Documentation

◆ MuonSelector() [1/2]

MuonSelector::MuonSelector ( )

Definition at line 44 of file MuonSelector.cxx.

44  :
45  m_muonSelectionTool("CP::MuonSelectionTool/MuonSelectionTool"),
46  m_doDebug ( false ),
47  m_doQualSelection ( false ),
48  m_doIsoSelection ( false ),
49  m_doPtSelection ( true ),
50  m_doIPSelection ( true ),
51  m_doMCPSelection ( true )
52 {
53  // SOC commented by Salva -- R22 test --
54  //++s_uNumInstances;
55  //std::stringstream xTmp; xTmp << s_uNumInstances;
56  //m_xSampleName = "MuID_" + xTmp.str();
57  // EOC commented by Salva -- R22 test --
58  unsigned int inst = ++m_uNumInstances;
59  m_xSampleName = "MuID_" + std::to_string(inst);
60  m_pxMuon = nullptr;
61  m_bLock = false;
62 
63 
64  // requested muon tag (tight, medium, loose..)
65  m_requestedMuonQuality = xAOD::Muon::Medium;
66 
67 
68  m_coneSize = 0.4;
69  m_ucJMuon_Cut = 0; //not used
70  m_IsoCut = 0.2;
71 
72  m_bCutOnCombKine = false; //not used
73  m_fEtaCut = 2.5;
74  //m_fEtaCut = 1.9;
75  m_combPtCut = 15.0*CLHEP::GeV; // GeV/c
76  // m_combPtCut = .01*CLHEP::GeV; // GeV/c
77 
78  //m_ptMSCut = 10.0*CLHEP::GeV;
79  m_ptMSCut = 0.0*CLHEP::GeV;
80  m_diffZCut = 1.5*CLHEP::mm; // mm --> used to be 10.0*CLHEP::mm // Changed by Salva 26/january/2016
81  m_diffPtCut = 15.0*CLHEP::GeV; // not used
82  m_pVZCut = 150.0*CLHEP::mm; // mm
83 
84  m_fIDPtCut = 0.0; // GeV/c
85  m_fIDChiPerDofCut = 4.0;
86  m_IDSiHitsCut = 8;
87  m_ucID_PIXCut = 1; // Hits
88  m_ucID_SCTCut = 4; // Hits
89  m_ucID_TRTCut = 0; // Hits
90 
91  m_msgStream = new MsgStream(PerfMonServices::getMessagingService(), "InDetPerformanceMonitoring");
92 
93  // stats
94  m_testedmuons = 0;
95  m_passqual = 0;
96  m_passiso = 0;
97  m_passpt = 0;
98  m_passip = 0;
99  m_passmcp = 0;
100  m_passall = 0;
101 
102  // done
103 }

◆ ~MuonSelector()

MuonSelector::~MuonSelector ( )

Definition at line 106 of file MuonSelector.cxx.

107 {
108  --m_uNumInstances;
109  delete m_msgStream;
110 }

◆ MuonSelector() [2/2]

MuonSelector::MuonSelector ( const MuonSelector &  )
delete

Member Function Documentation

◆ BookHistograms()

void MuonSelector::BookHistograms ( )
protectedvirtual

Reimplemented from EventAnalysis.

Definition at line 221 of file MuonSelector.cxx.

222 {
223 }

◆ calculateMomentum()

template<class T >
CLHEP::Hep3Vector EventAnalysis::calculateMomentum ( const T *  pP)
staticinherited

Definition at line 91 of file EventAnalysis.h.

91  {
92  const auto & p4(pP->p4());
93  return CLHEP::Hep3Vector(p4.Px() * EAna::CGeV , p4.Py() * EAna::CGeV, p4.Pz() * EAna::CGeV);
94 }

◆ doIPSelection()

void MuonSelector::doIPSelection ( bool  doIPsel)
inline

Definition at line 51 of file MuonSelector.h.

51 {m_doIPSelection = doIPsel;}

◆ doIsoSelection()

void MuonSelector::doIsoSelection ( bool  doIso)
inline

Definition at line 50 of file MuonSelector.h.

50 {m_doIsoSelection = doIso;}

◆ doMCPSelection()

void MuonSelector::doMCPSelection ( bool  domcp)
inline

Definition at line 52 of file MuonSelector.h.

52 {m_doMCPSelection = domcp;}

◆ EvalCharge()

template<class T >
float EventAnalysis::EvalCharge ( const T *  pxP1,
const T *  pxP2 
)
staticinherited

Definition at line 238 of file EventAnalysis.h.

239 {
240  // Check integrity of inputs.
241  if ( !pxP1 || !pxP2 ) return invalidAnswer;
242  return static_cast<float>( pxP1->charge() + pxP2->charge() );
243 }

◆ EvalDiMuInvMass()

template<class T >
float EventAnalysis::EvalDiMuInvMass ( const T *  pxP1,
const T *  pxP2 
)
staticinherited

Definition at line 97 of file EventAnalysis.h.

98 {
99  // Check integrity of inputs.
100  if ( !pxP1 || !pxP2 ) return invalidAnswer;
101 
102  // Evaluate Di-mu invariant mass.
103  return EvalInvMass( pxP1, pxP2, EAna::g_fMuonMass );
104 }

◆ EvalEta()

template<class T >
float EventAnalysis::EvalEta ( const T *  pxP1,
const T *  pxP2 
)
staticinherited

Definition at line 229 of file EventAnalysis.h.

230 {
231  // Check integrity of inputs.
232  if ( !pxP1 || !pxP2 ) return invalidAnswer;
233  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
234  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
235  return static_cast<float>( (xTmp1 + xTmp2).pseudoRapidity() );
236 }

◆ EvalEtaDiff()

template<class T >
float EventAnalysis::EvalEtaDiff ( const T *  pxP1,
const T *  pxP2 
)
staticinherited

Definition at line 201 of file EventAnalysis.h.

202 {
203  // Check integrity of inputs.
204  if ( !pxP1 || !pxP2 ) return invalidAnswer;
205  // Evaluate the angle.
206  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
207  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
208  return static_cast<float>( xTmp1.polarAngle(xTmp2) );
209 }

◆ EvalFourMuInvMass()

template<class T >
float EventAnalysis::EvalFourMuInvMass ( const T *  pxP1,
const T *  pxP2,
const T *  pxP3,
const T *  pxP4 
)
staticinherited

Definition at line 123 of file EventAnalysis.h.

124 {
125  // Check integrity of inputs.
126  if ( !pxP1 || !pxP2 || !pxP3 || !pxP4) return invalidAnswer;
127 
128  // Evaluate invariant mass.
129  return EvalInvMass( pxP1, pxP2, pxP3, pxP4, EAna::g_fMuonMass );
130 }

◆ EvalInvMass() [1/2]

template<class T >
float EventAnalysis::EvalInvMass ( const T *  pxP1,
const T *  pxP2,
const T *  pxp3,
const T *  pxP4,
float  fMass1,
float  fMass2 = -999.9,
float  fMass3 = -999.9,
float  fMass4 = invalidAnswer 
)
staticinherited

Definition at line 132 of file EventAnalysis.h.

134 {
135  // Check integrity of inputs.No tachyons.
136  if ( fMass1 < 0.0f ) return invalidAnswer;
137  if ( !pxP1 || !pxP2 || !pxP3 || !pxP4) return invalidAnswer;
138 
139  // Set masses equal if required by user
140  fMass2 = ( fMass2 < 0.0f ) ? fMass1 : fMass2;
141  fMass3 = ( fMass3 < 0.0f ) ? fMass1 : fMass3;
142  fMass4 = ( fMass4 < 0.0f ) ? fMass1 : fMass4;
143 
144  // Evaluate invariant mass.
145  CLHEP::Hep3Vector xTmp1 = CLHEP::Hep3Vector( pxP1->p4().Px() * EAna::CGeV, pxP1->p4().Py() * EAna::CGeV, pxP1->p4().Pz() * EAna::CGeV );
146  CLHEP::Hep3Vector xTmp2 = CLHEP::Hep3Vector( pxP2->p4().Px() * EAna::CGeV, pxP2->p4().Py() * EAna::CGeV, pxP2->p4().Pz() * EAna::CGeV );
147  CLHEP::Hep3Vector xTmp3 = CLHEP::Hep3Vector( pxP3->p4().Px() * EAna::CGeV, pxP3->p4().Py() * EAna::CGeV, pxP3->p4().Pz() * EAna::CGeV );
148  CLHEP::Hep3Vector xTmp4 = CLHEP::Hep3Vector( pxP4->p4().Px() * EAna::CGeV, pxP4->p4().Py() * EAna::CGeV, pxP4->p4().Pz() * EAna::CGeV );
149 
150  CLHEP::HepLorentzVector xLVec; xLVec.setVectM ( xTmp1, fMass1 );
151  CLHEP::HepLorentzVector xLVec2; xLVec2.setVectM( xTmp2, fMass2 );
152  CLHEP::HepLorentzVector xLVec3; xLVec3.setVectM( xTmp3, fMass3 );
153  CLHEP::HepLorentzVector xLVec4; xLVec4.setVectM( xTmp4, fMass4 );
154 
155  xLVec += xLVec2;
156  xLVec += xLVec3;
157  xLVec += xLVec4;
158 
159  return static_cast<float>( xLVec.m() );
160 }

◆ EvalInvMass() [2/2]

template<class T >
float EventAnalysis::EvalInvMass ( const T *  pxP1,
const T *  pxP2,
float  fMass1,
float  fMass2 = invalidAnswer 
)
staticinherited

Definition at line 106 of file EventAnalysis.h.

108 {
109  // Check integrity of inputs.No tachyons.
110  if ( fMass1 < 0.0f ) return invalidAnswer;
111  if ( !pxP1 || !pxP2 ) return invalidAnswer;
112  // Set masses equal if required by user
113  fMass2 = ( fMass2 < 0.0f ) ? fMass1 : fMass2;
114  // Evaluate invariant mass.
115  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
116  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
117  CLHEP::HepLorentzVector xLVec1; xLVec1.setVectM( xTmp1, fMass1 );
118  CLHEP::HepLorentzVector xLVec2; xLVec2.setVectM( xTmp2, fMass2 );
119  return static_cast<float>( xLVec1.invariantMass( xLVec2 ) );
120 }

◆ EvalPhi()

template<class T >
float EventAnalysis::EvalPhi ( const T *  pxP1,
const T *  pxP2 
)
staticinherited

Definition at line 220 of file EventAnalysis.h.

221 {
222  // Check integrity of inputs.
223  if ( !pxP1 || !pxP2 ) return invalidAnswer;
224  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
225  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
226  return static_cast<float>( (xTmp1 + xTmp2).phi() );
227 }

◆ EvalPhiDiff()

template<class T >
float EventAnalysis::EvalPhiDiff ( const T *  pxP1,
const T *  pxP2 
)
staticinherited

Definition at line 190 of file EventAnalysis.h.

191 {
192  // Check integrity of inputs.
193  if ( !pxP1 || !pxP2 ) return invalidAnswer;
194  // Evaluate the angle.
195  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
196  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
197  return static_cast<float>( xTmp1.deltaPhi(xTmp2) );
198 }

◆ EvalPt()

template<class T >
float EventAnalysis::EvalPt ( const T *  pxP1,
const T *  pxP2 
)
staticinherited

Definition at line 211 of file EventAnalysis.h.

212 {
213  // Check integrity of inputs.
214  if ( !pxP1 || !pxP2 ) return invalidAnswer;
215  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
216  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
217  return static_cast<float>( (xTmp1 + xTmp2).perp() );
218 }

◆ EvalPtDiff()

template<class T >
float EventAnalysis::EvalPtDiff ( const T *  pxP1,
const T *  pxP2 
)
staticinherited

Definition at line 173 of file EventAnalysis.h.

174 {
175  // Check integrity of inputs.
176  if ( !pxP1 || !pxP2 ) return invalidAnswer;
177  // Evaluate the difference between the momenta. Signed using positive - negative if appropriate.
178  if ( pxP1->charge() > 0.5f )
179  {
180  return static_cast<float>( pxP1->pt() * EAna::CGeV - pxP2->pt() * EAna::CGeV );
181  }
182  else
183  {
184  return static_cast<float>( pxP2->pt() * EAna::CGeV - pxP1->pt() * EAna::CGeV );
185  }
186 }

◆ EvalTransverseMass() [1/4]

template<class T >
float EventAnalysis::EvalTransverseMass ( const T *  pxP1,
const T *  pxP2,
float  fMETx,
float  fMETy 
)
staticinherited

Definition at line 271 of file EventAnalysis.h.

272 {
273  // Check integrity of inputs.
274  if ( !pxP1 || !pxP2 ) return invalidAnswer;
275  // Evaluate Di-mu invariant mass.
276  return EvalTransverseMass( pxP1, pxP2, fMETx, fMETy, EAna::g_fMuonMass );
277 }

◆ EvalTransverseMass() [2/4]

template<class T >
float EventAnalysis::EvalTransverseMass ( const T *  pxP1,
const T *  pxP2,
float  fMETx,
float  fMETy,
float  fMass1,
float  fMass2 = invalidAnswer 
)
staticinherited

Definition at line 279 of file EventAnalysis.h.

281 {
282  // Check integrity of inputs.No tachyons.
283  if ( fMass1 < 0.0f ) return invalidAnswer;
284  if ( !pxP1 || !pxP2 ) return invalidAnswer;
285  // Set masses equal if required by user.
286  fMass2 = ( fMass2 < 0.0f ) ? fMass1 : fMass2;
287  // Evaluate invariant mass.
288  CLHEP::Hep3Vector xTmp1 = CLHEP::Hep3Vector( pxP1->p4().Px() * EAna::CGeV, pxP1->p4().Py() * EAna::CGeV, 0.0f );
289  CLHEP::Hep3Vector xTmp2 = CLHEP::Hep3Vector( pxP2->p4().Px() * EAna::CGeV, pxP2->p4().Py() * EAna::CGeV, 0.0f );
290  CLHEP::Hep3Vector xTmp12 = xTmp1 + xTmp2;
291  CLHEP::Hep3Vector xTmp3 = CLHEP::Hep3Vector( fMETx, fMETy, 0.0f );
292  CLHEP::HepLorentzVector xLVec1; xLVec1.setVectM( xTmp12, fMass1 );
293  CLHEP::HepLorentzVector xLVec2; xLVec2.setVectM( xTmp3, 0.0f );
294  return static_cast<float>( xLVec1.invariantMass( xLVec2 ) );
295 }

◆ EvalTransverseMass() [3/4]

template<class T >
float EventAnalysis::EvalTransverseMass ( const T *  pxP1,
float  fMETx,
float  fMETy 
)
staticinherited

Definition at line 246 of file EventAnalysis.h.

247 {
248  // Check integrity of inputs.
249  if ( !pxP1 ) return invalidAnswer;
250  // Evaluate Di-mu invariant mass.
251  return EvalInvMass( pxP1, fMETx, fMETy, EAna::g_fMuonMass );
252 }

◆ EvalTransverseMass() [4/4]

template<class T >
float EventAnalysis::EvalTransverseMass ( const T *  pxP1,
float  fMETx,
float  fMETy,
float  fMass1,
float  fMass2 = invalidAnswer 
)
staticinherited

Definition at line 254 of file EventAnalysis.h.

256 {
257  // Check integrity of inputs.No tachyons.
258  if ( fMass1 < 0.0f ) return invalidAnswer;
259  if ( !pxP1 ) return invalidAnswer;
260  // Set masses equal if required by user.
261  fMass2 = ( fMass2 < 0.0f ) ? fMass1 : fMass2;
262  // Evaluate invariant mass.
263  CLHEP::Hep3Vector xTmp1 = CLHEP::Hep3Vector( pxP1->p4().Px() * EAna::CGeV, pxP1->p4().Py() * EAna::CGeV, 0.0f );
264  CLHEP::Hep3Vector xTmp2 = CLHEP::Hep3Vector( fMETx, fMETy, 0.0f );
265  CLHEP::HepLorentzVector xLVec1; xLVec1.setVectM( xTmp1, fMass1 );
266  CLHEP::HepLorentzVector xLVec2; xLVec2.setVectM( xTmp2, 0.0f );
267  return static_cast<float>( xLVec1.invariantMass( xLVec2 ) );
268 }

◆ EvaluateAngle()

template<class T >
float EventAnalysis::EvaluateAngle ( const T *  pxP1,
const T *  pxP2 
)
staticinherited

Definition at line 163 of file EventAnalysis.h.

164 {
165  // Check integrity of inputs.
166  if ( !pxP1 || !pxP2 ) return invalidAnswer;
167  // Evaluate the angle.
168  CLHEP::Hep3Vector xTmp1 = calculateMomentum(pxP1);
169  CLHEP::Hep3Vector xTmp2 = calculateMomentum(pxP2);
170  return static_cast<float>( xTmp1.angle(xTmp2) );
171 }

◆ finalize()

void MuonSelector::finalize ( )
virtual

Definition at line 461 of file MuonSelector.cxx.

462 {
463  // statistics report
464  std::cout << " * MuonSelector* -- STATS -- " << std::endl
465  << " tested : " << m_testedmuons << std::endl;
466  if (m_doQualSelection) std::cout << " passQual: " << m_passqual << std::endl;
467  if (m_doIsoSelection) std::cout << " passIso : " << m_passiso << std::endl;
468  if (m_doPtSelection) std::cout << " passpt : " << m_passpt << std::endl;
469  if (m_doIPSelection) std::cout << " passip : " << m_passip << std::endl;
470  if (m_doMCPSelection) std::cout << " passmcp : " << m_passmcp << std::endl;
471  std::cout << " passall : " << m_passall << std::endl
472  << std::endl;
473 
474  return;
475 }

◆ GetPtCut()

double MuonSelector::GetPtCut ( )
inline

Definition at line 55 of file MuonSelector.h.

55 {return m_combPtCut;}

◆ Init()

void MuonSelector::Init ( )
virtual

Reimplemented from EventAnalysis.

Definition at line 113 of file MuonSelector.cxx.

114 {
115 
116  ISvcLocator* serviceLocator = Gaudi::svcLocator();
117  IToolSvc* toolSvc;
118  StatusCode sc = serviceLocator->service("ToolSvc", toolSvc, true);
119 
120  if ( sc.isFailure() || toolSvc == nullptr ) {
121  (*m_msgStream) << MSG::ERROR << " * MuonSelector::Init * Unable to retrieve ToolSvc " << endmsg;
122  return;
123  }
124 
125  // check muon selection tool is available
126  if (m_muonSelectionTool.retrieve().isSuccess()) {
127  ( *m_msgStream) << MSG::INFO << " * MuonSelector::Init * m_muonSelectionTool.initialize() success :)" << endmsg;
128  if(m_doDebug){ std::cout << " * MuonSelector::Init * m_muonSelectionTool.initialize() success :)" << std::endl;}
129  }
130  else {
131  (*m_msgStream) << MSG::ERROR << " * MuonSelector::Init * FAILURE * Muon selction tool retrieving failed :( " << endmsg;
132  }
133 
134  PARENT::Init();
135 }

◆ operator=()

MuonSelector& MuonSelector::operator= ( const MuonSelector &  )
delete

◆ passIPCuts()

bool MuonSelector::passIPCuts ( )
private

Definition at line 359 of file MuonSelector.cxx.

360 {
361  float extd0 = 0.0 ;
362  float extz0 = 0.0 ;
363 
364  //I'm not really sure of this logic.
365  if (m_pxMuon->inDetTrackParticleLink().isValid()) {
366  const xAOD::TrackParticle* IDTrk = m_pxMuon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
367  if (!IDTrk) {
368  if (m_doDebug) std::cout << " * MuonSelector::passIPCuts * no IDTrk --> IP failure" << std::endl;
369  return false;
370  }
371  extd0 = IDTrk->d0();
372  extz0 = IDTrk->z0()+IDTrk->vz();
373  if(m_doDebug){
374  std::cout << " * MuonSelector::passIPCuts *"
375  << " the IDTrack muon d0: " << extd0
376  << " the IDTrack muon z0: " << extz0 << " = " << IDTrk->z0() << " + " << IDTrk->vz() << std::endl;
377  }
378  }
379  else {
380  if(m_doDebug) std::cout << " * MuonSelector * passIPCuts() * no valid inDetTrackParticleLink(). Will use the combined muon IPs" << std::endl;
381 
382  const xAOD::TrackParticle* CBTrk = m_pxMuon->trackParticle(xAOD::Muon::CombinedTrackParticle);
383  if (!CBTrk) {
384  if(m_doDebug) std::cout << " * MuonSelector * passIPCuts() * no valid CombinedTrackParticle. Giving up." << std::endl;
385  return false;
386  }
387  else {
388  extd0 = CBTrk->d0();
389  extz0 = CBTrk->z0()+CBTrk->vz();
390  if(m_doDebug){
391  std::cout << " * MuonSelector * passIPCuts() *"
392  << " the CBTrack muon d0: " << extd0
393  << " the CBTrack muon z0: " << extz0 << " = " << CBTrk->z0() << " + " << CBTrk->vz()<< std::endl;
394  }
395  }
396  }
397 
398  // retrieve the vertices
399  const xAOD::VertexContainer * vxContainer(nullptr);
400  vxContainer = PerfMonServices::getContainer <xAOD::VertexContainer> ( PerfMonServices::VTX_COLLECTION );
401  if (!vxContainer){
402  if(m_doDebug) std::cout << " * MuonSelector::passIPCuts ** fails because NO vertex collection "<< std::endl;
403  return false;
404  }
405 
406  if ( vxContainer->size()>1 ) {
407  if(m_doDebug) {
408  std::cout << " * MuonSelector::passIPCuts ** vertex container is filled with " << vxContainer->size() << " vertices" << std::endl;
409 
410  // loop on vertices to check their coordinates:
411  for (int ivtx=0; ivtx < (int) vxContainer->size(); ivtx++) {
412  const xAOD::Vertex* thisVtx = (*vxContainer)[ivtx];
413  std::cout << " vertex " << ivtx+1 << " (x,y,z) = (" << thisVtx->position().x()
414  << ", " << thisVtx->position().y()
415  << ", " << thisVtx->position().z()
416  << ") type= " << thisVtx->vertexType()
417  << " Npart= " << thisVtx->nTrackParticles()
418  << std::endl;
419  }
420  }
421 
422  // new method
423  if (true) {
424  bool goodmuonIP = false; // by default think the IP is not good
425  float minDeltaZ = 99999.; // large number
426  // loop on vertices and check the muon may come from one of them
427  for (int ivtx=0; ivtx < (int) vxContainer->size(); ivtx++) {
428  const xAOD::Vertex* thisVtx = (*vxContainer)[ivtx];
429  // if ( (thisVtx->vertexType() == 1) && thisVtx->nTrackParticles()>2 ) {
430  if ( thisVtx->nTrackParticles()>2 ) {
431  if (std::abs(extz0 - thisVtx->position().z()) < minDeltaZ) minDeltaZ = std::abs(extz0 - thisVtx->position().z());
432 
433  // check the vertex is in the accepted Z range and that the muon is not far from the vertex
434  if (m_doDebug) {
435  std::cout << " testing vtx: " << ivtx << " vtx.z= " << thisVtx->position().z() << " trk.z= " << extz0 << " deltaZ= " << std::abs(extz0 - thisVtx->position().z()) << " minDeltaZ= " << minDeltaZ << std::endl;
436  }
437  if (std::abs(thisVtx->position().z()) < m_pVZCut && std::abs(extz0 - thisVtx->position().z()) < m_diffZCut){
438  goodmuonIP = true;
439  if(m_doDebug) std::cout << " * MuonSelector::passIPCuts * this muon has passed the IPCuts for vertex " << ivtx+1
440  << " pVZcut= " << std::abs(extz0 - thisVtx->position().z()) << " < " << m_diffZCut << std::endl
441  << " vtx (x,y,z): "
442  << " (" << thisVtx->position().x()
443  << ", " << thisVtx->position().y()
444  << ", " << thisVtx->position().z()
445  << ") type: " << thisVtx->vertexType()
446  << " Npart: " << thisVtx->nTrackParticles() << std::endl;
447  }
448  }
449  }
450  if (goodmuonIP) {
451  if(m_doDebug) std::cout <<" * MuonSelector::passIPCuts * this muon has passed the IPCuts. Zcut: "<< m_pVZCut << " m_diffZCut " << m_diffZCut << std::endl;
452  return true;
453  }
454  } // end new method
455  }
456  if(m_doDebug) std::cout <<" * MuonSelector * passIPCuts() * this muon has not passed the IPCuts: " << std::endl;
457  return false;
458 }

◆ passIsolCuts()

bool MuonSelector::passIsolCuts ( )
private

Definition at line 330 of file MuonSelector.cxx.

331 {
332  float iso_pt40(0);
333  if( !m_pxMuon->isolation(iso_pt40, xAOD::Iso::ptcone40) ) {
334  if(m_doDebug) {
335  std::cout << " * MuonSelector::passIsolCuts * WARNING * No isolation variable stored on the muon" << std::endl;
336  std::cout << " * MuonSelector::passIsolCuts * this muon did not pass the IsoCuts " << std::endl;
337  }
338  return false;
339  }
340 
341  else {
342  double pt = m_pxMuon->pt();
343  double ptSum = xAOD::Iso::ptcone40;
344  if(m_doDebug) std::cout <<" * MuonSelector::passIsolCuts * muon pt: " << pt <<" ptSum(ptcone40): "<< ptSum << std::endl;
345  if (ptSum/pt < m_IsoCut ){
346  if(m_doDebug) std::cout << " * MuonSelector::passIsolCuts * this muon passed the IsoCuts ptcone40 / pt= "
347  << ptSum << " / " << pt << " = " << ptSum / pt
348  << " < IsoCut(" << m_IsoCut << ") " << std::endl;
349  return true;
350  }
351  }
352 
353  if(m_doDebug) std::cout << " * MuonSelector::passIsolCuts * this muon did not pass the IsoCuts:" << std::endl;
354  return false;
355 }

◆ passPtCuts()

bool MuonSelector::passPtCuts ( )
private

Definition at line 284 of file MuonSelector.cxx.

285 {
286 
287  if(m_doDebug) std::cout << " * MuonSelector::passPtCuts * START *" << std::endl;
288 
289  const xAOD::TrackParticle* pxMuonID = m_pxMuon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
290  const xAOD::TrackParticle* pxMuonMS = m_pxMuon->trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
291  const xAOD::TrackParticle* pxMuonCB = m_pxMuon->trackParticle(xAOD::Muon::CombinedTrackParticle);
292 
293  double pt = 0, ptID, ptMS,ptCB;
294 
295  if ( !(pxMuonID || pxMuonMS || pxMuonCB)){
296  if(m_doDebug) std::cout << " * MuonSelector::passPtCuts * NO inDetTrackParticle && muonSpectrometerTrackParticle && CombinedTrackParticle: " << std::endl;
297  }
298 
299  else {
300 
301  pt = m_pxMuon->pt();
302  ptID = pxMuonID ? pxMuonID->pt() : 0.0 ;
303  ptMS = pxMuonMS ? pxMuonMS->pt() : 0.0 ;
304  ptCB = pxMuonCB ? pxMuonCB->pt() : 0.0 ;
305  double fMEta = std::abs( m_pxMuon->eta() );
306 
307  if(m_doDebug) std::cout << " * MuonSelector::passPtCuts * pt of each segments of this muon pxMuon: " << pt << std::endl
308  << " ptID: " << ptID << std::endl
309  << " ptMS: " << ptMS << std::endl
310  << " ptCB: " << ptCB << std::endl
311  << " fMEta pxMuon->eta(): " << fMEta << std::endl;
312 
313 
314  if ( (fMEta < m_fEtaCut)
315  && (pt > m_combPtCut)
316  && (ptMS > m_ptMSCut || !pxMuonMS)
317  && (ptID > m_ptMSCut || !pxMuonID)
318  ){
319  // warning one can check also the difference of pt: std::abs(ptMS - ptID) < m_diffPtCut
320  if(m_doDebug) std::cout << " * MuonSelector::passPtCuts * this muon is in eta range |eta|= " << fMEta << " < EtaCut(" << m_fEtaCut << ") " << std::endl
321  << " and passed the PtCuts (" << m_combPtCut <<") "<< std::endl;
322  return true;
323  }
324  }
325  if(m_doDebug) std::cout << " * MuonSelector::passPtCuts * this muon did not pass the PtCuts (reco pt=" << pt << ") or Eta cut " << m_fEtaCut << std::endl;
326  return false;
327 }

◆ passQualCuts()

bool MuonSelector::passQualCuts ( )
private

Definition at line 229 of file MuonSelector.cxx.

230 {
231  bool goodTrack = false;
232 
233  // First get the muon track, then the summary
234  const xAOD::TrackParticle* IDTrk = m_pxMuon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle); // use the Inner Detector segment
235 
236  if (IDTrk) {
237  uint8_t dummy(-1);
238  bool eBLhits = IDTrk->summaryValue( dummy, xAOD::expectBLayerHit ) ? true : false;
239  int nBLhits = IDTrk->summaryValue( dummy, xAOD::numberOfBLayerHits ) ? dummy :-1;
240 
241  int nhitsPIX = IDTrk->summaryValue( dummy, xAOD::numberOfPixelHits ) ? dummy :-1;
242  int nhitsSCT = IDTrk->summaryValue( dummy, xAOD::numberOfSCTHits ) ? dummy :-1;
243  int nhitsTRT = IDTrk->summaryValue( dummy, xAOD::numberOfTRTHits ) ? dummy :-1;
244 
245  int nPIXDS = IDTrk->summaryValue( dummy, xAOD::numberOfPixelDeadSensors ) ? dummy :-1;
246  int nSCTDS = IDTrk->summaryValue( dummy, xAOD::numberOfSCTDeadSensors ) ? dummy :-1;
247 
248  int nPIXH = IDTrk->summaryValue( dummy, xAOD::numberOfPixelHoles )? dummy :-1;
249  int nSCTH = IDTrk->summaryValue( dummy, xAOD::numberOfSCTHoles )? dummy :-1;
250  int nTRTH = IDTrk->summaryValue( dummy, xAOD::numberOfTRTHoles )? dummy :-1;
251 
252  int nContribPixLayers = IDTrk->summaryValue( dummy, xAOD::numberOfContribPixelLayers )? dummy :-1;
253 
254  if(m_doDebug) std::cout << " * MuonSelector * passQualCuts() * eBLhits: " << eBLhits
255  << " nBLhits: " << nBLhits
256  << " nhitsPIX: " << nhitsPIX
257  << " nPIXLayers: " << nContribPixLayers
258  << " nhitsSCT: " << nhitsSCT
259  << " Silicon holes: " << nPIXH + nSCTH
260  << " nhitsTRT: " << nhitsTRT
261  << " nTRTholes: " << nTRTH
262  << std::endl;
263 
264  if (((!eBLhits) || (nBLhits > 0))
265  && (nhitsPIX + nPIXDS > 1 )
266  && (nhitsSCT + nSCTDS >=6 )
267  && (nPIXH + nSCTH < 2 ) ) {
268  goodTrack = true;
269  }
270  }
271 
272  if (m_doDebug) {
273  if (goodTrack) {
274  std::cout << " * MuonSelector * passQualCuts() * this muon satisfies the hits number QualCuts " << std::endl;
275  }
276  else {
277  std::cout << " * MuonSelector * passQualCuts() * this muon did not pass the hits number QualCuts " << std::endl;
278  }
279  }
280  return goodTrack;
281 }

◆ passSelection()

bool MuonSelector::passSelection ( const xAOD::Muon *  pxMuon)

Definition at line 146 of file MuonSelector.cxx.

147 {
148  if(m_doDebug){ std::cout << " * MuonSelector::passSelection * START * new muon " << pxMuon << " with pt: " << pxMuon->pt() << std::endl; }
149 
150  std::vector<bool> passes;
151  bool pass = true;
152  if ( pxMuon ) {
153  // Save local copy of muon address if it's ok.
154  m_pxMuon = pxMuon;
155  m_testedmuons++;
156 
157  // Test muon pass conditions in turn
158  if(m_doQualSelection){
159  pass = passQualCuts();
160  passes.push_back(pass);
161  if (m_doDebug && !pass) std::cout <<" * MuonSelector::passSelection * Muon Fails QualSelection"<<std::endl;
162  if (pass) m_passqual++;
163  }
164 
165  if (m_doIsoSelection){
166  pass = passIsolCuts();
167  passes.push_back(pass);
168  if (m_doDebug && !pass) std::cout<<" * MuonSelector::passSelection * Muon Fails Iso Selection"<<std::endl;
169  if (pass) m_passiso++;
170  }
171 
172 
173  if (m_doPtSelection){
174  pass = passPtCuts();
175  passes.push_back(pass);
176  if (m_doDebug && !pass) std::cout<<" * MuonSelector::passSelection * Muon Fails pT Selection"<<std::endl;
177  if (pass) m_passpt++;
178  }
179 
180  if (m_doIPSelection){
181  pass = passIPCuts();
182  passes.push_back(pass);
183  if (m_doDebug && !pass) std::cout<<" * MuonSelector::passSelection * Muon Fails IP Selection"<<std::endl;
184  if (pass) m_passip++;
185  }
186 
187  if (m_doMCPSelection) {
188  xAOD::Muon::Quality my_quality=m_muonSelectionTool->getQuality(*pxMuon);
189  if (m_doDebug) std::cout << " * MuonSelector::passSelection * muon quality from muonsSelectionTool: " << my_quality << std::endl;
190 
191  pass = true;
192  if (m_requestedMuonQuality == xAOD::Muon::Tight && my_quality > xAOD::Muon::Tight) pass = false;
193  if (m_requestedMuonQuality == xAOD::Muon::Medium && my_quality > xAOD::Muon::Medium) pass = false;
194  if (m_requestedMuonQuality == xAOD::Muon::Loose && my_quality > xAOD::Muon::Loose) pass = false;
195  if (m_requestedMuonQuality == xAOD::Muon::VeryLoose && my_quality > xAOD::Muon::VeryLoose) pass = false;
196 
197  passes.push_back(pass);
198  if (m_doDebug && pass) std::cout<<" * MuonSelector::passSelection * Muon Passes official m_muonSelectionTool (medium) Selection :)" << std::endl;
199  if (m_doDebug && !pass) std::cout<<" * MuonSelector::passSelection * Muon Fails official m_muonSelectionTool (medium) Selection" << std::endl;
200  if (pass) m_passmcp++;
201  }
202 
203  // check if the muon failed some of the cuts
204  for (int i=0; i < int(passes.size()); i++)
205  if (!passes[i]){
206  if(m_doDebug) std::cout << " * MuonSelector::passSelection * BAD MUON * muon haven't passed the " << i+1 << "th selection " << std::endl;
207  return false;
208  }
209  } // if pxMuon exists
210 
211  // reached this point, the muon passed all selection criteria. This muon is good
212  m_passall++;
213  if(m_doDebug){ std::cout << " * MuonSelector::passSelection * completed. GOOD MUON " << std::endl; }
214  return true;
215 }

◆ Reco()

bool MuonSelector::Reco ( )
virtual

Definition at line 139 of file MuonSelector.cxx.

140 {
141  return true;
142 }

◆ Register()

void EventAnalysis::Register ( )
privateinherited

Definition at line 64 of file EventAnalysis.cxx.

65 {
66  ServiceHandle<ITHistSvc> histSvc ("THistSvc", "EventAnalysis");
67 
68  // Register histograms in monitoring tool
69  registerHistogramType(*histSvc, m_x1DHistograms, m_xSampleName, "/1dhisto_");
70  registerHistogramType(*histSvc, m_x2DHistograms, m_xSampleName, "/2dhisto_");
71 
72  registerHistogramType(*histSvc, m_x1DProfHistograms, m_xSampleName, "/1dprof_");
73  registerHistogramType(*histSvc, m_x2DProfHistograms, m_xSampleName, "/2dprof_");
74 }

◆ SetCustomMuonSelectionTool()

void MuonSelector::SetCustomMuonSelectionTool ( ToolHandle< CP::IMuonSelectionTool >  mst)
inline

Definition at line 58 of file MuonSelector.h.

58 { m_muonSelectionTool = mst; };

◆ setDebug()

void MuonSelector::setDebug ( bool  debug)
inline

Definition at line 44 of file MuonSelector.h.

44 {m_doDebug = debug;}

◆ SetMuonQualityRequirement()

void MuonSelector::SetMuonQualityRequirement ( std::string  newname)

Definition at line 478 of file MuonSelector.cxx.

479 {
480  int qualityvalue = xAOD::Muon::Tight;
481 
482  for_each (newname.begin(), newname.end(), [](char & c) {c = std::toupper(c);} );
483 
484  if (newname.find("TIGHT") != std::string::npos) qualityvalue = xAOD::Muon::Tight;
485  if (newname.find("MEDIUM") != std::string::npos) qualityvalue = xAOD::Muon::Medium;
486  if (newname.find("LOOSE") != std::string::npos) qualityvalue = xAOD::Muon::Loose;
487  if (newname.find("VERYLOOSE")!= std::string::npos) qualityvalue = xAOD::Muon::VeryLoose;
488 
489  m_requestedMuonQuality = qualityvalue;
490 
491  std::cout << " ** MuonSelector::SetMuonQualityRequirement(" << newname <<") = " << m_requestedMuonQuality << std::endl;
492 
493  return;
494 }

◆ SetPtCut()

void MuonSelector::SetPtCut ( double  newvalue)
inline

Definition at line 54 of file MuonSelector.h.

54 {m_combPtCut = newvalue;}

Member Data Documentation

◆ invalidAnswer

constexpr float EventAnalysis::invalidAnswer {-999.9f}
staticconstexprinherited

Definition at line 39 of file EventAnalysis.h.

◆ m_bCutOnCombKine

bool MuonSelector::m_bCutOnCombKine
private

Definition at line 91 of file MuonSelector.h.

◆ m_bLock

bool MuonSelector::m_bLock
private

Definition at line 116 of file MuonSelector.h.

◆ m_combPtCut

double MuonSelector::m_combPtCut
private

Definition at line 94 of file MuonSelector.h.

◆ m_coneSize

double MuonSelector::m_coneSize {}
private

Definition at line 84 of file MuonSelector.h.

◆ m_diffPtCut

float MuonSelector::m_diffPtCut
private

Definition at line 97 of file MuonSelector.h.

◆ m_diffZCut

float MuonSelector::m_diffZCut
private

Definition at line 96 of file MuonSelector.h.

◆ m_doDebug

bool MuonSelector::m_doDebug
private

Definition at line 108 of file MuonSelector.h.

◆ m_doIPSelection

bool MuonSelector::m_doIPSelection
private

Definition at line 112 of file MuonSelector.h.

◆ m_doIsoSelection

bool MuonSelector::m_doIsoSelection
private

Definition at line 110 of file MuonSelector.h.

◆ m_doMCPSelection

bool MuonSelector::m_doMCPSelection
private

Definition at line 113 of file MuonSelector.h.

◆ m_doPtSelection

bool MuonSelector::m_doPtSelection
private

Definition at line 111 of file MuonSelector.h.

◆ m_doQualSelection

bool MuonSelector::m_doQualSelection
private

Definition at line 109 of file MuonSelector.h.

◆ m_fEtaCut

float MuonSelector::m_fEtaCut
private

Definition at line 92 of file MuonSelector.h.

◆ m_fIDChiPerDofCut

float MuonSelector::m_fIDChiPerDofCut
private

Definition at line 102 of file MuonSelector.h.

◆ m_fIDPtCut

float MuonSelector::m_fIDPtCut
private

Definition at line 101 of file MuonSelector.h.

◆ m_IDSiHitsCut

int MuonSelector::m_IDSiHitsCut
private

Definition at line 103 of file MuonSelector.h.

◆ m_IsoCut

double MuonSelector::m_IsoCut
private

Definition at line 89 of file MuonSelector.h.

◆ m_msgStream

MsgStream* MuonSelector::m_msgStream
private

Definition at line 75 of file MuonSelector.h.

◆ m_muonSelectionTool

ToolHandle<CP::IMuonSelectionTool> MuonSelector::m_muonSelectionTool

Definition at line 45 of file MuonSelector.h.

◆ m_passall

unsigned int MuonSelector::m_passall {}
private

Definition at line 125 of file MuonSelector.h.

◆ m_passip

unsigned int MuonSelector::m_passip {}
private

Definition at line 123 of file MuonSelector.h.

◆ m_passiso

unsigned int MuonSelector::m_passiso {}
private

Definition at line 121 of file MuonSelector.h.

◆ m_passmcp

unsigned int MuonSelector::m_passmcp {}
private

Definition at line 124 of file MuonSelector.h.

◆ m_passpt

unsigned int MuonSelector::m_passpt {}
private

Definition at line 122 of file MuonSelector.h.

◆ m_passqual

unsigned int MuonSelector::m_passqual {}
private

Definition at line 120 of file MuonSelector.h.

◆ m_ptMSCut

float MuonSelector::m_ptMSCut
private

Definition at line 95 of file MuonSelector.h.

◆ m_pVZCut

float MuonSelector::m_pVZCut
private

Definition at line 98 of file MuonSelector.h.

◆ m_pxMuon

const xAOD::Muon* MuonSelector::m_pxMuon
private

Definition at line 78 of file MuonSelector.h.

◆ m_requestedMuonQuality

int MuonSelector::m_requestedMuonQuality {}
private

Definition at line 81 of file MuonSelector.h.

◆ m_testedmuons

unsigned int MuonSelector::m_testedmuons {}
private

Definition at line 119 of file MuonSelector.h.

◆ m_ucID_PIXCut

unsigned char MuonSelector::m_ucID_PIXCut
private

Definition at line 104 of file MuonSelector.h.

◆ m_ucID_SCTCut

unsigned char MuonSelector::m_ucID_SCTCut
private

Definition at line 105 of file MuonSelector.h.

◆ m_ucID_TRTCut

unsigned char MuonSelector::m_ucID_TRTCut
private

Definition at line 106 of file MuonSelector.h.

◆ m_ucJMuon_Cut

unsigned char MuonSelector::m_ucJMuon_Cut
private

Definition at line 88 of file MuonSelector.h.

◆ m_uNumInstances

unsigned int MuonSelector::m_uNumInstances = 0U
private

Definition at line 67 of file MuonSelector.h.

◆ m_uPassedEvents

unsigned int EventAnalysis::m_uPassedEvents
protectedinherited

Definition at line 74 of file EventAnalysis.h.

◆ m_x1DHistograms

std::map<unsigned int, TH1F*> EventAnalysis::m_x1DHistograms
protectedinherited

Definition at line 75 of file EventAnalysis.h.

◆ m_x1DProfHistograms

std::map<unsigned int, TProfile*> EventAnalysis::m_x1DProfHistograms
protectedinherited

Definition at line 77 of file EventAnalysis.h.

◆ m_x2DHistograms

std::map<unsigned int, TH2F*> EventAnalysis::m_x2DHistograms
protectedinherited

Definition at line 76 of file EventAnalysis.h.

◆ m_x2DProfHistograms

std::map<unsigned int, TProfile2D*> EventAnalysis::m_x2DProfHistograms
protectedinherited

Definition at line 78 of file EventAnalysis.h.

◆ m_xSampleName

std::string EventAnalysis::m_xSampleName
protectedinherited

Definition at line 80 of file EventAnalysis.h.

The documentation for this class was generated from the following files:
EventAnalysis::EvalInvMass
static float EvalInvMass(const T *pxP1, const T *pxP2, float fMass1, float fMass2=invalidAnswer)
Definition: EventAnalysis.h:106
MuonSelector::m_coneSize
double m_coneSize
Definition: MuonSelector.h:84
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:261
LikeEnum::Loose
@ Loose
Definition: LikelihoodEnums.h:12
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
MuonSelector::m_doDebug
bool m_doDebug
Definition: MuonSelector.h:108
MuonSelector::ECONE
@ ECONE
Definition: MuonSelector.h:130
PerfMonServices::getMessagingService
static IMessageSvc * getMessagingService()
Definition: PerfMonServices.h:36
xAOD::Muon_v1::isolation
bool isolation(float &value, const Iso::IsolationType information) const
Accessor for Isolation values.
Definition: Muon_v1.cxx:279
MuonSelector::m_pVZCut
float m_pVZCut
Definition: MuonSelector.h:98
xAOD::Vertex_v1::nTrackParticles
size_t nTrackParticles() const
Get the number of tracks associated with this vertex.
Definition: Vertex_v1.cxx:270
LikeEnum::VeryLoose
@ VeryLoose
Definition: LikelihoodEnums.h:11
MuonSelector::m_passmcp
unsigned int m_passmcp
Definition: MuonSelector.h:124
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
xAOD::expectBLayerHit
@ expectBLayerHit
Do we expect a b-layer hit for this track? [unit8_t] (should be [bool])
Definition: TrackingPrimitives.h:235
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
xAOD::Muon_v1::trackParticle
const TrackParticle * trackParticle(TrackParticleType type) const
Returns a pointer (which can be NULL) to the TrackParticle used in identification of this muon.
Definition: Muon_v1.cxx:504
MuonSelector::m_fIDChiPerDofCut
float m_fIDChiPerDofCut
Definition: MuonSelector.h:102
perp
Scalar perp() const
perp method - perpenticular length
Definition: AmgMatrixBasePlugin.h:35
MuonSelector::m_msgStream
MsgStream * m_msgStream
Definition: MuonSelector.h:75
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:736
xAOD::TrackParticle_v1::vz
float vz() const
The z origin for the parameters.
MuonSelector::m_ptMSCut
float m_ptMSCut
Definition: MuonSelector.h:95
MuonSelector::m_passip
unsigned int m_passip
Definition: MuonSelector.h:123
MuonSelector::m_ucID_SCTCut
unsigned char m_ucID_SCTCut
Definition: MuonSelector.h:105
xAOD::Muon_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
test_pyathena.pt
pt
Definition: test_pyathena.py:11
MuonSelector::NCSC
@ NCSC
Definition: MuonSelector.h:130
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
MuonSelector::m_ucID_TRTCut
unsigned char m_ucID_TRTCut
Definition: MuonSelector.h:106
MuonSelector::m_passpt
unsigned int m_passpt
Definition: MuonSelector.h:122
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
xAOD::Vertex_v1::position
const Amg::Vector3D & position() const
Returns the 3-pos.
MuonSelector::m_bCutOnCombKine
bool m_bCutOnCombKine
Definition: MuonSelector.h:91
xAOD::Vertex_v1::vertexType
VxType::VertexType vertexType() const
The type of the vertex.
EventAnalysis::m_x1DHistograms
std::map< unsigned int, TH1F * > m_x1DHistograms
Definition: EventAnalysis.h:75
xAOD::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the first pixel layer, i.e.
Definition: TrackingPrimitives.h:231
MuonSelector::m_ucID_PIXCut
unsigned char m_ucID_PIXCut
Definition: MuonSelector.h:104
xAOD::TrackParticle_v1::d0
float d0() const
Returns the parameter.
MuonSelector::m_muonSelectionTool
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition: MuonSelector.h:45
MuonSelector::m_pxMuon
const xAOD::Muon * m_pxMuon
Definition: MuonSelector.h:78
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
MuonSelector::passPtCuts
bool passPtCuts()
Definition: MuonSelector.cxx:284
MuonSelector::NMDT
@ NMDT
Definition: MuonSelector.h:130
MuonSelector::m_uNumInstances
unsigned int m_uNumInstances
Definition: MuonSelector.h:67
MuonSelector::m_doPtSelection
bool m_doPtSelection
Definition: MuonSelector.h:111
MuonSelector::passIPCuts
bool passIPCuts()
Definition: MuonSelector.cxx:359
MuonSelector::m_diffPtCut
float m_diffPtCut
Definition: MuonSelector.h:97
EventAnalysis::m_x2DHistograms
std::map< unsigned int, TH2F * > m_x2DHistograms
Definition: EventAnalysis.h:76
MuonSelector::NUM_1HISTOS
@ NUM_1HISTOS
Definition: MuonSelector.h:131
EventAnalysis::EvalTransverseMass
static float EvalTransverseMass(const T *pxP1, float fMETx, float fMETy, float fMass1, float fMass2=invalidAnswer)
Definition: EventAnalysis.h:254
MuonSelector::m_requestedMuonQuality
int m_requestedMuonQuality
Definition: MuonSelector.h:81
EventAnalysis::calculateMomentum
static CLHEP::Hep3Vector calculateMomentum(const T *pP)
Definition: EventAnalysis.h:91
lumiFormat.i
int i
Definition: lumiFormat.py:92
MuonSelector::m_combPtCut
double m_combPtCut
Definition: MuonSelector.h:94
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
MuonSelector::m_fIDPtCut
float m_fIDPtCut
Definition: MuonSelector.h:101
MuonSelector::m_IDSiHitsCut
int m_IDSiHitsCut
Definition: MuonSelector.h:103
MuonSegmentReaderConfig.histSvc
histSvc
Definition: MuonSegmentReaderConfig.py:96
MuonSelector::m_IsoCut
double m_IsoCut
Definition: MuonSelector.h:89
xAOD::Muon_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
MuonSelector::m_ucJMuon_Cut
unsigned char m_ucJMuon_Cut
Definition: MuonSelector.h:88
python.xAODType.dummy
dummy
Definition: xAODType.py:4
MuonSelector::m_testedmuons
unsigned int m_testedmuons
Definition: MuonSelector.h:119
MuonSelector::m_doIsoSelection
bool m_doIsoSelection
Definition: MuonSelector.h:110
PerfMonServices::VTX_COLLECTION
@ VTX_COLLECTION
Definition: PerfMonServices.h:65
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
MuonSelector::passQualCuts
bool passQualCuts()
Definition: MuonSelector.cxx:229
MuonSelector::m_doQualSelection
bool m_doQualSelection
Definition: MuonSelector.h:109
LikeEnum::Tight
@ Tight
Definition: LikelihoodEnums.h:15
EventAnalysis::m_x1DProfHistograms
std::map< unsigned int, TProfile * > m_x1DProfHistograms
Definition: EventAnalysis.h:77
MuonSelector::m_doMCPSelection
bool m_doMCPSelection
Definition: MuonSelector.h:113
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
MuonSelector::m_diffZCut
float m_diffZCut
Definition: MuonSelector.h:96
xAOD::Iso::ptcone40
@ ptcone40
Definition: IsolationType.h:42
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
xAOD::Muon_v1::inDetTrackParticleLink
const ElementLink< TrackParticleContainer > & inDetTrackParticleLink() const
Returns an ElementLink to the InnerDetector TrackParticle used in identification of this muon.
MuonSelector::m_passiso
unsigned int m_passiso
Definition: MuonSelector.h:121
EventAnalysis::m_x2DProfHistograms
std::map< unsigned int, TProfile2D * > m_x2DProfHistograms
Definition: EventAnalysis.h:78
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
MuonSelector::passIsolCuts
bool passIsolCuts()
Definition: MuonSelector.cxx:330
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
xAOD::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:273
EAna::g_fMuonMass
const float g_fMuonMass
Definition: EventAnalysis.h:26
MuonSelector::m_doIPSelection
bool m_doIPSelection
Definition: MuonSelector.h:112
MuonSelector::m_bLock
bool m_bLock
Definition: MuonSelector.h:116
xAOD::numberOfContribPixelLayers
@ numberOfContribPixelLayers
number of contributing layers of the pixel detector [unit8_t].
Definition: TrackingPrimitives.h:230
createCoolChannelIdFile.newname
newname
Definition: createCoolChannelIdFile.py:106
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
MuonSelector::m_passall
unsigned int m_passall
Definition: MuonSelector.h:125
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:266
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
EventAnalysis::Init
virtual void Init()
Definition: EventAnalysis.cxx:45
xAOD::numberOfTRTHoles
@ numberOfTRTHoles
number of TRT holes [unit8_t].
Definition: TrackingPrimitives.h:277
EventAnalysis::m_xSampleName
std::string m_xSampleName
Definition: EventAnalysis.h:80
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
python.compressB64.c
def c
Definition: compressB64.py:93
EAna::CGeV
const float CGeV
Definition: EventAnalysis.h:28
EventAnalysis::invalidAnswer
static constexpr float invalidAnswer
Definition: EventAnalysis.h:39
MuonSelector::m_fEtaCut
float m_fEtaCut
Definition: MuonSelector.h:92
ServiceHandle< ITHistSvc >
MuonSelector::m_passqual
unsigned int m_passqual
Definition: MuonSelector.h:120
Generated on Fri Jul 5 2024 21:54:36 for ATLAS Offline Software by   doxygen 1.8.18