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 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 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 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
MuonSelector::m_doDebug
bool m_doDebug
Definition: MuonSelector.h:108
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
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:261
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:67
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
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:486
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: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
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: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: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
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
hist_file_dump.f
f
Definition: hist_file_dump.py:135
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:270
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
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: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:320
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:44
xAOD::numberOfTRTHoles
@ numberOfTRTHoles
number of TRT holes [unit8_t].
Definition: TrackingPrimitives.h:277
EventAnalysis::m_xSampleName
std::string m_xSampleName
Definition: EventAnalysis.h:80
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 Thu Nov 7 2024 21:52:58 for ATLAS Offline Software by   doxygen 1.8.18