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 43 of file MuonSelector.cxx.

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

◆ ~MuonSelector()

MuonSelector::~MuonSelector ( )

Definition at line 105 of file MuonSelector.cxx.

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

◆ MuonSelector() [2/2]

MuonSelector::MuonSelector ( const MuonSelector &  )
delete

Member Function Documentation

◆ BookHistograms()

void MuonSelector::BookHistograms ( )
protectedvirtual

Reimplemented from EventAnalysis.

Definition at line 211 of file MuonSelector.cxx.

212 {
213 }

◆ calculateMomentum()

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

Definition at line 92 of file EventAnalysis.h.

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

◆ 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 239 of file EventAnalysis.h.

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

◆ EvalDiMuInvMass()

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

Definition at line 98 of file EventAnalysis.h.

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

◆ EvalEta()

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

Definition at line 230 of file EventAnalysis.h.

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

◆ EvalEtaDiff()

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

Definition at line 202 of file EventAnalysis.h.

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

◆ EvalFourMuInvMass()

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

Definition at line 124 of file EventAnalysis.h.

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

◆ 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 133 of file EventAnalysis.h.

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

◆ EvalInvMass() [2/2]

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

Definition at line 107 of file EventAnalysis.h.

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

◆ EvalPhi()

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

Definition at line 221 of file EventAnalysis.h.

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

◆ EvalPhiDiff()

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

Definition at line 191 of file EventAnalysis.h.

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

◆ EvalPt()

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

Definition at line 212 of file EventAnalysis.h.

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

◆ EvalPtDiff()

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

Definition at line 174 of file EventAnalysis.h.

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

◆ EvalTransverseMass() [1/4]

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

Definition at line 272 of file EventAnalysis.h.

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

◆ 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 280 of file EventAnalysis.h.

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

◆ EvalTransverseMass() [3/4]

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

Definition at line 247 of file EventAnalysis.h.

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

◆ 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 255 of file EventAnalysis.h.

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

◆ EvaluateAngle()

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

Definition at line 164 of file EventAnalysis.h.

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

◆ finalize()

void MuonSelector::finalize ( )
virtual

Definition at line 451 of file MuonSelector.cxx.

452 {
453  // statistics report
454  std::cout << " * MuonSelector* -- STATS -- " << std::endl
455  << " tested : " << m_testedmuons << std::endl;
456  if (m_doQualSelection) std::cout << " passQual: " << m_passqual << std::endl;
457  if (m_doIsoSelection) std::cout << " passIso : " << m_passiso << std::endl;
458  if (m_doPtSelection) std::cout << " passpt : " << m_passpt << std::endl;
459  if (m_doIPSelection) std::cout << " passip : " << m_passip << std::endl;
460  if (m_doMCPSelection) std::cout << " passmcp : " << m_passmcp << std::endl;
461  std::cout << " passall : " << m_passall << std::endl
462  << std::endl;
463 
464  return;
465 }

◆ 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 112 of file MuonSelector.cxx.

113 {
114 
115  // check muon selection tool is available
116  if (m_muonSelectionTool.retrieve().isSuccess()) {
117  ( *m_msgStream) << MSG::INFO << " * MuonSelector::Init * m_muonSelectionTool.initialize() success :)" << endmsg;
118  if(m_doDebug){ std::cout << " * MuonSelector::Init * m_muonSelectionTool.initialize() success :)" << std::endl;}
119  }
120  else {
121  (*m_msgStream) << MSG::ERROR << " * MuonSelector::Init * FAILURE * Muon selction tool retrieving failed :( " << endmsg;
122  }
123 
124  PARENT::Init();
125 }

◆ operator=()

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

◆ passIPCuts()

bool MuonSelector::passIPCuts ( )
private

Definition at line 349 of file MuonSelector.cxx.

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

◆ passIsolCuts()

bool MuonSelector::passIsolCuts ( )
private

Definition at line 320 of file MuonSelector.cxx.

321 {
322  float iso_pt40(0);
323  if( !m_pxMuon->isolation(iso_pt40, xAOD::Iso::ptcone40) ) {
324  if(m_doDebug) {
325  std::cout << " * MuonSelector::passIsolCuts * WARNING * No isolation variable stored on the muon" << std::endl;
326  std::cout << " * MuonSelector::passIsolCuts * this muon did not pass the IsoCuts " << std::endl;
327  }
328  return false;
329  }
330 
331  else {
332  double pt = m_pxMuon->pt();
333  double ptSum = xAOD::Iso::ptcone40;
334  if(m_doDebug) std::cout <<" * MuonSelector::passIsolCuts * muon pt: " << pt <<" ptSum(ptcone40): "<< ptSum << std::endl;
335  if (ptSum/pt < m_IsoCut ){
336  if(m_doDebug) std::cout << " * MuonSelector::passIsolCuts * this muon passed the IsoCuts ptcone40 / pt= "
337  << ptSum << " / " << pt << " = " << ptSum / pt
338  << " < IsoCut(" << m_IsoCut << ") " << std::endl;
339  return true;
340  }
341  }
342 
343  if(m_doDebug) std::cout << " * MuonSelector::passIsolCuts * this muon did not pass the IsoCuts:" << std::endl;
344  return false;
345 }

◆ passPtCuts()

bool MuonSelector::passPtCuts ( )
private

Definition at line 274 of file MuonSelector.cxx.

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

◆ passQualCuts()

bool MuonSelector::passQualCuts ( )
private

Definition at line 219 of file MuonSelector.cxx.

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

◆ passSelection()

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

Definition at line 136 of file MuonSelector.cxx.

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

◆ Reco()

bool MuonSelector::Reco ( )
virtual

Definition at line 129 of file MuonSelector.cxx.

130 {
131  return true;
132 }

◆ Register()

void EventAnalysis::Register ( )
privateinherited

Definition at line 63 of file EventAnalysis.cxx.

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

◆ 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 468 of file MuonSelector.cxx.

469 {
470  int qualityvalue = xAOD::Muon::Tight;
471 
472  for_each (newname.begin(), newname.end(), [](char & c) {c = std::toupper(c);} );
473 
474  if (newname.find("TIGHT") != std::string::npos) qualityvalue = xAOD::Muon::Tight;
475  if (newname.find("MEDIUM") != std::string::npos) qualityvalue = xAOD::Muon::Medium;
476  if (newname.find("LOOSE") != std::string::npos) qualityvalue = xAOD::Muon::Loose;
477  if (newname.find("VERYLOOSE")!= std::string::npos) qualityvalue = xAOD::Muon::VeryLoose;
478 
479  m_requestedMuonQuality = qualityvalue;
480 
481  std::cout << " ** MuonSelector::SetMuonQualityRequirement(" << newname <<") = " << m_requestedMuonQuality << std::endl;
482 
483  return;
484 }

◆ 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 40 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 75 of file EventAnalysis.h.

◆ m_x1DHistograms

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

Definition at line 76 of file EventAnalysis.h.

◆ m_x1DProfHistograms

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

Definition at line 78 of file EventAnalysis.h.

◆ m_x2DHistograms

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

Definition at line 77 of file EventAnalysis.h.

◆ m_x2DProfHistograms

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

Definition at line 79 of file EventAnalysis.h.

◆ m_xSampleName

std::string EventAnalysis::m_xSampleName
protectedinherited

Definition at line 81 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:107
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:74
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:262
LikeEnum::Loose
@ Loose
Definition: LikelihoodEnums.h:12
MuonSelector::m_doDebug
bool m_doDebug
Definition: MuonSelector.h:108
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:18
MuonSelector::ECONE
@ ECONE
Definition: MuonSelector.h:130
xAOD::Muon_v1::isolation
bool isolation(float &value, const Iso::IsolationType information) const
Accessor for Isolation values.
Definition: Muon_v1.cxx:262
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
python.SystemOfUnits.mm
float mm
Definition: SystemOfUnits.py:98
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:67
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
xAOD::expectBLayerHit
@ expectBLayerHit
Do we expect a b-layer hit for this track? [unit8_t] (should be [bool])
Definition: TrackingPrimitives.h:236
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:487
MuonSelector::m_fIDChiPerDofCut
float m_fIDChiPerDofCut
Definition: MuonSelector.h:102
perp
Scalar perp() const
perp method - perpenticular length
Definition: AmgMatrixBasePlugin.h:44
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:737
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:260
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:276
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:76
xAOD::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the first pixel layer, i.e.
Definition: TrackingPrimitives.h:232
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
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
MuonSelector::passPtCuts
bool passPtCuts()
Definition: MuonSelector.cxx:274
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:349
MuonSelector::m_diffPtCut
float m_diffPtCut
Definition: MuonSelector.h:97
EventAnalysis::m_x2DHistograms
std::map< unsigned int, TH2F * > m_x2DHistograms
Definition: EventAnalysis.h:77
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:255
MuonSelector::m_requestedMuonQuality
int m_requestedMuonQuality
Definition: MuonSelector.h:81
EventAnalysis::calculateMomentum
static CLHEP::Hep3Vector calculateMomentum(const T *pP)
Definition: EventAnalysis.h:92
lumiFormat.i
int i
Definition: lumiFormat.py:85
MuonSelector::m_combPtCut
double m_combPtCut
Definition: MuonSelector.h:94
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
MuonSelector::m_fIDPtCut
float m_fIDPtCut
Definition: MuonSelector.h:101
MuonSelector::m_IDSiHitsCut
int m_IDSiHitsCut
Definition: MuonSelector.h:103
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
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
MuonSelector::m_testedmuons
unsigned int m_testedmuons
Definition: MuonSelector.h:119
hist_file_dump.f
f
Definition: hist_file_dump.py:140
MuonSelector::m_doIsoSelection
bool m_doIsoSelection
Definition: MuonSelector.h:110
PerfMonServices::VTX_COLLECTION
@ VTX_COLLECTION
Definition: PerfMonServices.h:46
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:271
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
MuonSelector::passQualCuts
bool passQualCuts()
Definition: MuonSelector.cxx:219
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:78
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
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:79
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
MuonSelector::passIsolCuts
bool passIsolCuts()
Definition: MuonSelector.cxx:320
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
xAOD::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:274
EAna::g_fMuonMass
const float g_fMuonMass
Definition: EventAnalysis.h:27
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:231
createCoolChannelIdFile.newname
newname
Definition: createCoolChannelIdFile.py:105
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
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:267
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
EventAnalysis::Init
virtual void Init()
Definition: EventAnalysis.cxx:44
xAOD::numberOfTRTHoles
@ numberOfTRTHoles
number of TRT holes [unit8_t].
Definition: TrackingPrimitives.h:278
EventAnalysis::m_xSampleName
std::string m_xSampleName
Definition: EventAnalysis.h:81
python.compressB64.c
def c
Definition: compressB64.py:93
EAna::CGeV
const float CGeV
Definition: EventAnalysis.h:29
EventAnalysis::invalidAnswer
static constexpr float invalidAnswer
Definition: EventAnalysis.h:40
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 Sun Aug 31 2025 21:42:34 for ATLAS Offline Software by   doxygen 1.8.18