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

#include <ZmumuEvent.h>

Inheritance diagram for ZmumuEvent:
Collaboration diagram for ZmumuEvent:

Public Types

enum  {
  MUON1, MUON2, MUON3_OVR1, MUON4_OVR2,
  NUM_MUONS
}
 
enum  { CENTRAL, FORWARD, BACKWARD, UNDEF }
 
enum  ZTYPE {
  MS, ME, ID, CB,
  NUM_TYPES
}
 

Public Member Functions

 ZmumuEvent ()
 
virtual ~ZmumuEvent ()
 
virtual void Init ()
 
virtual bool Reco (int theLumiBlock=0)
 
void doIsoSelection (bool doIso)
 
void doIPSelection (bool doIPsel)
 
void doMCPSelection (bool doMCP)
 
bool AcceptEvent ()
 
void finalize ()
 
unsigned int getAcceptedEvents ()
 
const xAOD::Muon * getCombMuon (unsigned int uPart)
 
const xAOD::TrackParticle * getIDTrack (unsigned int uPart)
 
double GetInvMass ()
 
const float & getLeptonOpeningAngle (ZTYPE eType)
 
const xAOD::TrackParticle *getLooseIDTk ATLAS_NOT_REENTRANT (unsigned int uPart)
 
const xAOD::TrackParticle * getMSTrack (unsigned int uPart)
 
unsigned int getNegMuon (ZTYPE eType)
 
unsigned int getNumberOfTaggedMuons ()
 
unsigned int getPosMuon (ZTYPE eType)
 
float getPtImbalance (ZTYPE eType)
 
const std::string getRegion () const
 
unsigned int getTestedMuonCount ()
 
int getZCharge (ZTYPE eType)
 
const float & getZEta (ZTYPE eType)
 
const float & getZMass (ZTYPE eType)
 
const float & getZPhi (ZTYPE eType)
 
const float & getZPt (ZTYPE eType)
 
void OrderMuonList ()
 
void setDebugMode (bool debug)
 
void SetMaxLumiBlock (int newlumiblock)
 
void SetMinLumiBlock (int newlumiblock)
 
void SetMuonPtCut (double newvalue)
 
void SetMuonQuality (const std::string &newname)
 
void SetMassWindowLow (double newvalue)
 
void SetMassWindowHigh (double newvalue)
 
void SetLeadingMuonPtCut (double newvalue)
 
void SetSecondMuonPtCut (double newvalue)
 
void SetOpeningAngleCut (double newvalue)
 
void SetZ0GapCut (double newvalue)
 
void SetSkipMSCheck (bool value)
 
void setContainer (PerfMonServices::CONTAINERS container)
 
void SetMuonSelectionTool (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)
 

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 {
  ZMASS_MUON, ZMASS_MUONADJ, ZMASS_TRACK, ZMASS_COMB,
  NUM_1HISTOS
}
 
typedef EventAnalysis PARENT
 

Private Member Functions

void Clear ()
 
bool EventSelection (ZTYPE eType)
 
void ReconstructKinematics ()
 
bool RecordMuon (const xAOD::Muon *pxMuon)
 
void Register ()
 

Private Attributes

MuonSelector m_xMuonID
 
PerfMonServices::CONTAINERS m_container
 
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
 
unsigned int m_uMuonTags
 
unsigned int m_uTrackMatch
 
bool m_bLooseMatch
 
double m_etaCut
 
double m_DiMuonPairInvMass = 0.0
 
double m_LeadingMuonPtCut
 
double m_SecondMuonPtCut
 
double m_MassWindowLow
 
double m_MassWindowHigh
 
double m_OpeningAngleCut
 
double m_Z0GapCut
 
bool m_skipMScheck
 
int m_minGoodLumiBlock
 
int m_maxGoodLumiBlock
 
bool m_doDebug
 
unsigned int m_numberOfFullPassMuons {}
 
bool m_passedSelectionCuts {}
 
int m_analyzedEventCount {}
 
unsigned int m_eventsWithoutEnoughMuonsCount {}
 
unsigned int m_eventsWithEnoughMuonsCount {}
 
unsigned int m_acceptedEventCount {}
 
unsigned int m_testedMuonCount {}
 
unsigned int m_acceptedMuonCount {}
 
unsigned int m_eventselectioncount_toofewmuons {}
 
unsigned int m_eventselectioncount_notallmuonsfilled {}
 
unsigned int m_eventselectioncount_morethantwomuons {}
 
unsigned int m_eventselectioncount_ptofleadingmuon {}
 
unsigned int m_eventselectioncount_ptofsecondmuon {}
 
unsigned int m_eventselectioncount_masswindow {}
 
unsigned int m_eventselectioncount_openingangle {}
 
unsigned int m_eventselectioncount_dimuoncharge {}
 
unsigned int m_eventselectioncount_goodlumiblock {}
 
const xAOD::Muon * m_pxRecMuon [NUM_MUONS] {}
 
const xAOD::TrackParticle * m_pxMETrack [NUM_MUONS] {}
 
const xAOD::TrackParticle * m_pxMSTrack [NUM_MUONS] {}
 
const xAOD::TrackParticle * m_pxIDTrack [NUM_MUONS] {}
 
float m_fZPt [NUM_TYPES] {}
 
float m_fZEtaDir [NUM_TYPES] {}
 
float m_fZPhiDir [NUM_TYPES] {}
 
float m_fInvariantMass [NUM_TYPES] {}
 
float m_fMuonDispersion [NUM_TYPES] {}
 
bool m_SelectMuonByIso
 
bool m_SelectMuonByIP
 
int m_muon1 = 0
 
int m_muon2 = 0
 

Detailed Description

Definition at line 27 of file ZmumuEvent.h.

Member Typedef Documentation

◆ PARENT

typedef EventAnalysis ZmumuEvent::PARENT
private

Definition at line 109 of file ZmumuEvent.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
Enumerator
MUON1 
MUON2 
MUON3_OVR1 
MUON4_OVR2 
NUM_MUONS 

Definition at line 33 of file ZmumuEvent.h.

34  {
35  MUON1,
36  MUON2,
37  MUON3_OVR1,
38  MUON4_OVR2,
39  NUM_MUONS
40  };

◆ anonymous enum

anonymous enum
Enumerator
CENTRAL 
FORWARD 
BACKWARD 
UNDEF 

Definition at line 42 of file ZmumuEvent.h.

43  {
44  CENTRAL,
45  FORWARD,
46  BACKWARD,
47  UNDEF
48  };

◆ HISTOS_1D

enum ZmumuEvent::HISTOS_1D
private
Enumerator
ZMASS_MUON 
ZMASS_MUONADJ 
ZMASS_TRACK 
ZMASS_COMB 
NUM_1HISTOS 

Definition at line 173 of file ZmumuEvent.h.

174  {
175  ZMASS_MUON, ZMASS_MUONADJ, ZMASS_TRACK, ZMASS_COMB,
176  NUM_1HISTOS
177  };

◆ ZTYPE

enum ZmumuEvent::ZTYPE
Enumerator
MS 
ME 
ID 
CB 
NUM_TYPES 

Definition at line 50 of file ZmumuEvent.h.

51  {
52  MS, // Just the muon system ( uncorrected )
53  ME, // The adjusted muon system properties ( corr. for cal. )
54  ID, // Using the ID system.
55  CB, // Using both the muon & ID system.
56  NUM_TYPES
57  };

Constructor & Destructor Documentation

◆ ZmumuEvent()

ZmumuEvent::ZmumuEvent ( )

Definition at line 36 of file ZmumuEvent.cxx.

37 {
38  m_xSampleName = "ZMM";
39 
40  m_container = PerfMonServices::MUID_COLLECTION;
41 
42  m_doDebug = false;
43 
44  // Setup the muon tags
45  m_uMuonTags = 2;
46  m_uTrackMatch = 0;
47  m_bLooseMatch = true; // will use combined fit otherwise.
48  m_etaCut = 1.05;
49  m_LeadingMuonPtCut = 20.;
50  m_SecondMuonPtCut = 15.;
51  m_MassWindowLow = 60.0;
52  m_MassWindowHigh = 120.0;
53  m_OpeningAngleCut = 0.2; // in radians
54  m_Z0GapCut = 5.0; // in mm
55  m_minGoodLumiBlock = 0;
56  m_maxGoodLumiBlock = 0;
57  m_SelectMuonByIso = true;
58  m_SelectMuonByIP = true;
59  m_analyzedEventCount = 0;
60  m_eventsWithoutEnoughMuonsCount = 0;
61  m_eventsWithEnoughMuonsCount = 0;
62  m_acceptedEventCount = 0;
63  m_testedMuonCount = 0;
64  m_acceptedMuonCount = 0;
65  m_eventselectioncount_toofewmuons = 0;
66  m_eventselectioncount_notallmuonsfilled = 0;
67  m_eventselectioncount_morethantwomuons = 0;
68  m_eventselectioncount_ptofleadingmuon = 0;
69  m_eventselectioncount_ptofsecondmuon = 0;
70  m_eventselectioncount_masswindow = 0;
71  m_eventselectioncount_openingangle = 0;
72  m_eventselectioncount_dimuoncharge = 0;
73  m_eventselectioncount_goodlumiblock = 0;
74  m_skipMScheck = false;
75 
76  return;
77 }

◆ ~ZmumuEvent()

ZmumuEvent::~ZmumuEvent ( )
virtual

Definition at line 80 of file ZmumuEvent.cxx.

81 {
82 }

Member Function Documentation

◆ AcceptEvent()

bool ZmumuEvent::AcceptEvent ( )
inline

Definition at line 67 of file ZmumuEvent.h.

67 { return m_passedSelectionCuts; }

◆ ATLAS_NOT_REENTRANT()

const xAOD::TrackParticle* getLooseIDTk ZmumuEvent::ATLAS_NOT_REENTRANT ( unsigned int  uPart)

◆ BookHistograms()

void ZmumuEvent::BookHistograms ( )
protectedvirtual

Reimplemented from EventAnalysis.

Definition at line 211 of file ZmumuEvent.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 }

◆ Clear()

void ZmumuEvent::Clear ( )
private

Definition at line 361 of file ZmumuEvent.cxx.

362 {
363  m_numberOfFullPassMuons = 0;
364  m_passedSelectionCuts = false;
365  m_DiMuonPairInvMass = -1.; // flag as no reconstructed inv mass yet
366  m_muon1 = MUON1; // point to the first two
367  m_muon2 = MUON2;
368 
369  for ( unsigned int u = 0; u < NUM_MUONS; ++u ) {
370  m_pxRecMuon[u] = nullptr;
371  m_pxMSTrack[u] = nullptr;
372  m_pxMETrack[u] = nullptr;
373  m_pxIDTrack[u] = nullptr;
374  }
375  for ( unsigned int v = 0; v < NUM_TYPES; ++v ) {
376  m_fZPt[v] = -999.9f;
377  m_fZEtaDir[v] = -999.9f;
378  m_fZPhiDir[v] = -999.9f;
379  m_fInvariantMass[v] = -999.9f;
380  m_fMuonDispersion[v] = -999.9f;
381  }
382  return;
383 }

◆ doIPSelection()

void ZmumuEvent::doIPSelection ( bool  doIPsel)
inline

Definition at line 65 of file ZmumuEvent.h.

65 { m_xMuonID.doIPSelection(doIPsel); }

◆ doIsoSelection()

void ZmumuEvent::doIsoSelection ( bool  doIso)
inline

Definition at line 64 of file ZmumuEvent.h.

64 { m_xMuonID.doIsoSelection(doIso); }

◆ doMCPSelection()

void ZmumuEvent::doMCPSelection ( bool  doMCP)
inline

Definition at line 66 of file ZmumuEvent.h.

66 { m_xMuonID.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 }

◆ EventSelection()

bool ZmumuEvent::EventSelection ( ZTYPE  eType)
private

Definition at line 218 of file ZmumuEvent.cxx.

219 {
220  if(m_doDebug) {std::cout <<" * ZmumuEvent * Event selection ** START ** for type: " << eType << " m_NumberOfFullPassMuons: " << m_numberOfFullPassMuons << std::endl;}
221 
222  // First require two muon-id's with cuts pre-applied.
223  if ( m_numberOfFullPassMuons < 2 ) {
224  if (m_doDebug) {std::cout <<" * ZmumuEvent * Failing number of good muons == 2 :( " << m_numberOfFullPassMuons << std::endl;}
225  return false;
226  }
227  m_eventselectioncount_toofewmuons++;
228 
229  // crosscheck all muons have been properly filled
230  bool allMuonsGood = true;
231  for (unsigned int muonid=0; muonid < m_numberOfFullPassMuons; muonid++) {
232  if (!m_pxMSTrack[muonid]) {
233  allMuonsGood = false;
234  }
235  }
236  if (!allMuonsGood){
237  return false;
238  }
239  m_eventselectioncount_notallmuonsfilled++;
240 
241  if ( m_numberOfFullPassMuons > 2 ) {
242  if (m_doDebug) {std::cout <<" * ZmumuEvent * Failing number of good muons == 2 :( " << m_numberOfFullPassMuons << std::endl;}
243  return false;
244  }
245  m_eventselectioncount_morethantwomuons++;
246 
247  // momentum of the muons
248  double leadingMuonPt, secondMuonPt;
249  switch ( eType )
250  {
251  case MS :
252  {
253  leadingMuonPt = m_pxMSTrack[m_muon1]->pt();
254  secondMuonPt = m_pxMSTrack[m_muon2]->pt();
255  break;
256  }
257  case ME:
258  {
259  leadingMuonPt = m_pxMETrack[m_muon1]->pt();
260  secondMuonPt = m_pxMETrack[m_muon2]->pt();
261  break;
262  }
263  case CB:
264  {
265  leadingMuonPt = m_pxRecMuon[m_muon1]->pt();
266  secondMuonPt = m_pxRecMuon[m_muon2]->pt();
267  break;
268  }
269  case ID:
270  {
271  leadingMuonPt = m_pxIDTrack[m_muon1]->pt();
272  secondMuonPt = m_pxIDTrack[m_muon2]->pt();
273  break;
274  }
275 
276  default:
277  leadingMuonPt = m_pxRecMuon[m_muon1]->pt();
278  secondMuonPt = m_pxRecMuon[m_muon2]->pt();
279  }
280  // up to here the leading and second pt are not really in the right order.
281  // order the muon pt:
282  if (secondMuonPt > leadingMuonPt) {
283  double tempPt = leadingMuonPt;
284  leadingMuonPt = secondMuonPt;
285  secondMuonPt = tempPt;
286  }
287 
288  // muon pt cut
289  // if ( !(leadingMuonPt > m_LeadingMuonPtCut*CLHEP::GeV && secondMuonPt > m_SecondMuonPtCut*CLHEP::GeV ) ) {
290  if ( leadingMuonPt < m_LeadingMuonPtCut*CLHEP::GeV ) {
291  if(m_doDebug){ std::cout <<" * ZmumuEvent * Failing 1st muon pt cut * Reco Pt: " << leadingMuonPt << " < " << m_LeadingMuonPtCut*CLHEP::GeV << std::endl;}
292  return false;
293  }
294  m_eventselectioncount_ptofleadingmuon++;
295 
296  if ( secondMuonPt < m_SecondMuonPtCut*CLHEP::GeV ) {
297  if(m_doDebug){ std::cout <<" * ZmumuEvent * Failing 2nd muon pt cut * Reco Pt: " << secondMuonPt << " < " << m_SecondMuonPtCut*CLHEP::GeV << std::endl;}
298  return false;
299  }
300  m_eventselectioncount_ptofsecondmuon++;
301 
302  // Invariant mass window
303  if ( m_fInvariantMass[eType] < m_MassWindowLow ) {
304  if(m_doDebug) {std::cout <<" * ZmumuEvent * Failing mass window low cut: reco m= " << m_fInvariantMass[eType] << " > " << m_MassWindowLow << std::endl;}
305  return false;
306  }
307  if ( m_fInvariantMass[eType] > m_MassWindowHigh ) {
308  if(m_doDebug) {std::cout <<" * ZmumuEvent * Failing mass window high cut: reco m= " << m_fInvariantMass[eType] << " > " << m_MassWindowHigh << std::endl;}
309  return false;
310  }
311  m_eventselectioncount_masswindow++;
312 
313  // opening angle
314  if ( m_fMuonDispersion[eType] < m_OpeningAngleCut ) {
315  if(m_doDebug) {std::cout <<" * ZmumuEvent * Failing opening angle cut. Opening angle " << m_fMuonDispersion[eType] << " < " << m_OpeningAngleCut << std::endl;}
316  return false;
317  }
318  m_eventselectioncount_openingangle++;
319 
320  // opposite charge
321  if ( getZCharge(eType) != 0 ) {
322  if(m_doDebug) {
323  std::cout <<" * ZmumuEvent * Failing get ZCharge != 0 cut * Reco q1= " << m_pxRecMuon[m_muon1]->charge()*m_pxRecMuon[m_muon1]->pt() <<std::endl;
324  //<< " q2= " << m_pxRecMuon[m_muon2]->charge()*m_pxRecMuon[m_muon2]->pt() << std::endl; //This might not exist!
325  std::cout <<" * ID q1= " << m_pxIDTrack[m_muon1]->charge()*m_pxIDTrack[m_muon1]->pt() << std::endl;
326  // << " q2= " << m_pxIDTrack[m_muon2]->charge()*m_pxIDTrack[m_muon2]->pt() << std::endl; //This might not exist!
327  }
328  return false;
329  }
330  m_eventselectioncount_dimuoncharge++;
331 
332  //
333  // both muons should come from the same vertex
334  // if the vertex information is used, that is already guaranteed, but if not, one has to check the z0
335  if (eType == ID) {
336  double z0_muon1 = m_pxIDTrack[m_muon1]->vz() + m_pxIDTrack[m_muon1]->z0();
337  double z0_muon2 = m_pxIDTrack[m_muon2]->vz() + m_pxIDTrack[m_muon2]->z0();
338  if(m_doDebug) {
339  std::cout << " * ZmumuEvent * z0_muon1= " << z0_muon1 << " z0_muon2= " << z0_muon2 << " delta= " << z0_muon1-z0_muon2 << std::endl;
340  }
341  if ( std::abs(z0_muon1 - z0_muon2) > m_Z0GapCut) {
342  if(m_doDebug) {
343  std::cout << " * ZmumuEvent * Failing common vertex cut. z.vtx1= " << m_pxIDTrack[m_muon1]->vz() << " z.vtx2= " << m_pxIDTrack[m_muon2]->vz() << std::endl;
344  std::cout << " * ZmumuEvent * Failing common vertex cut. IDTrk.z0_1= " << m_pxIDTrack[m_muon1]->z0() << " IDTrk.z0_2= " << m_pxIDTrack[m_muon2]->z0() << std::endl;
345  std::cout << " * ZmumuEvent * z0_muon1= " << z0_muon1 << " z0_muon2= " << z0_muon2 << " delta= " << z0_muon1-z0_muon2 << " > " << m_Z0GapCut << " (cut)" << std::endl;
346  }
347  return false;
348  }
349  }
350 
351 
352  if(m_doDebug) {
353  std::cout <<" * ZmumuEvent * Good muon pair: pt= " << leadingMuonPt/1000
354  << " & " << secondMuonPt/1000
355  << " GeV dimuon invariant mass = " << m_fInvariantMass[eType] << " GeV " << std::endl;
356  }
357  return true;
358 }

◆ finalize()

void ZmumuEvent::finalize ( )

Definition at line 669 of file ZmumuEvent.cxx.

670 {
671  m_xMuonID.finalize();
672 
673  std::cout << " ** ZmumuEvent ** -- STATS -- " << std::endl
674  << " Analyzed events : " << m_analyzedEventCount << std::endl
675  << " Events passing LumiBlock : " << m_eventselectioncount_goodlumiblock << std::endl
676  << " Tested muons : " << m_testedMuonCount << std::endl
677  << " Accepted muons : " << m_acceptedMuonCount << std::endl
678  << " Events without enough muon: " << m_eventsWithoutEnoughMuonsCount << std::endl
679  << " Events with enough muons : " << m_eventsWithEnoughMuonsCount << std::endl
680  << " pass few muons : " << m_eventselectioncount_toofewmuons << std::endl
681  << " pass not filled muons : " << m_eventselectioncount_notallmuonsfilled << std::endl
682  << " pass more than 2 muons : " << m_eventselectioncount_morethantwomuons << std::endl
683  << " pass pt lead : " << m_eventselectioncount_ptofleadingmuon << std::endl
684  << " pass pt 2nd : " << m_eventselectioncount_ptofsecondmuon << std::endl
685  << " pass mass window : " << m_eventselectioncount_masswindow << std::endl
686  << " pass opening angle : " << m_eventselectioncount_openingangle << std::endl
687  << " pass dimuon charge : " << m_eventselectioncount_dimuoncharge << std::endl
688  << " Accepted events : " << m_acceptedEventCount << std::endl
689  << std::endl;
690  return;
691 }

◆ getAcceptedEvents()

unsigned int ZmumuEvent::getAcceptedEvents ( )
inline

Definition at line 69 of file ZmumuEvent.h.

69 { return m_acceptedEventCount; }

◆ getCombMuon()

const xAOD::Muon* ZmumuEvent::getCombMuon ( unsigned int  uPart)
inline

Definition at line 70 of file ZmumuEvent.h.

70 { return (uPart < NUM_MUONS) ? m_pxRecMuon[uPart] : NULL; }

◆ getIDTrack()

const xAOD::TrackParticle* ZmumuEvent::getIDTrack ( unsigned int  uPart)
inline

Definition at line 71 of file ZmumuEvent.h.

71 { return (uPart < NUM_MUONS) ? m_pxIDTrack[uPart] : NULL; }

◆ GetInvMass()

double ZmumuEvent::GetInvMass ( )
inline

Definition at line 72 of file ZmumuEvent.h.

72 {return m_DiMuonPairInvMass;}

◆ getLeptonOpeningAngle()

const float& ZmumuEvent::getLeptonOpeningAngle ( ZTYPE  eType)
inline

Definition at line 73 of file ZmumuEvent.h.

73 { return m_fMuonDispersion[eType]; }

◆ getMSTrack()

const xAOD::TrackParticle* ZmumuEvent::getMSTrack ( unsigned int  uPart)
inline

Definition at line 75 of file ZmumuEvent.h.

75 { return (uPart < NUM_MUONS) ? m_pxMSTrack[uPart] : NULL; }

◆ getNegMuon()

unsigned int ZmumuEvent::getNegMuon ( ZTYPE  eType)

Definition at line 549 of file ZmumuEvent.cxx.

550 {
551  int uTmp = getPosMuon( eType );
552  if ( uTmp == 999 )
553  {
554  return 999;
555  }
556  else
557  {
558  return ( ( uTmp == m_muon1 ) ? m_muon2 : m_muon1 );
559  }
560 }

◆ getNumberOfTaggedMuons()

unsigned int ZmumuEvent::getNumberOfTaggedMuons ( )
inline

Definition at line 77 of file ZmumuEvent.h.

77 { return m_numberOfFullPassMuons; }

◆ getPosMuon()

unsigned int ZmumuEvent::getPosMuon ( ZTYPE  eType)

Definition at line 516 of file ZmumuEvent.cxx.

517 {
518  if ( getNumberOfTaggedMuons() != 2 ) return 999;
519  if ( getZCharge(eType) != 0 ) return 999;
520 
521  switch ( eType )
522  {
523  case MS :
524  {
525  if ( !m_pxMSTrack[m_muon1] || !m_pxMSTrack[m_muon2] ) return 999;
526  return ( static_cast<int>( m_pxMSTrack[m_muon1]->charge() ) == 1 ? m_muon1 : m_muon2 );
527  }
528  case ME:
529  {
530  if ( !m_pxMETrack[m_muon1] || !m_pxMETrack[m_muon2] ) return 999;
531  return ( static_cast<int>( m_pxMETrack[m_muon1]->charge() ) == 1 ? m_muon1 : m_muon2 );
532  }
533  case CB:
534  {
535  if ( !m_pxRecMuon[m_muon1] || !m_pxRecMuon[m_muon2] ) return 999;
536  return ( static_cast<int>( m_pxRecMuon[m_muon1]->charge() ) == 1 ? m_muon1 : m_muon2 );
537  }
538  case ID:
539  {
540  if ( !m_pxIDTrack[m_muon1] || !m_pxIDTrack[m_muon2] ) return 999;
541  return ( static_cast<int>( m_pxIDTrack[m_muon1]->charge() ) == 1 ? m_muon1 : m_muon2 );
542  }
543  default:
544  return 999;
545  }
546 }

◆ getPtImbalance()

float ZmumuEvent::getPtImbalance ( ZTYPE  eType)

Definition at line 456 of file ZmumuEvent.cxx.

457 {
458  // First determine what's positive
459  if ( m_numberOfFullPassMuons == 2 )
460  {
461  switch ( eType )
462  {
463  case MS :
464  {
465  return EvalPtDiff( m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
466  }
467  case ME:
468  {
469  return EvalPtDiff( m_pxMETrack[m_muon1], m_pxMETrack[m_muon2] );
470  }
471  case CB:
472  {
473  return EvalPtDiff( m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
474  }
475  case ID:
476  {
477  return EvalPtDiff( m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] );
478  }
479  default:
480  return -999.0;
481  }
482  }
483  else
484  {
485  return -999.0;
486  }
487 }

◆ getRegion()

const std::string ZmumuEvent::getRegion ( ) const

Definition at line 95 of file ZmumuEvent.cxx.

95  {
96 
97  const double eta1 = std::abs(m_pxRecMuon[m_muon1]->eta());
98  const double eta2 = std::abs(m_pxRecMuon[m_muon2]->eta());
99 
100  if ( eta1 < m_etaCut && eta2 < m_etaCut )
101  return "BB";
102 
103  else if( (eta1 < m_etaCut && eta2 > m_etaCut) || (eta1 > m_etaCut && eta2 < m_etaCut) )
104  return "BE";
105 
106  else return "EE";
107 }

◆ getTestedMuonCount()

unsigned int ZmumuEvent::getTestedMuonCount ( )
inline

Definition at line 81 of file ZmumuEvent.h.

81 { return m_testedMuonCount; }

◆ getZCharge()

int ZmumuEvent::getZCharge ( ZTYPE  eType)

Definition at line 490 of file ZmumuEvent.cxx.

491 {
492  switch ( eType )
493  {
494  case MS :
495  {
496  return ( static_cast<int>( EvalCharge( m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] ) ) );
497  }
498  case ME:
499  {
500  return ( static_cast<int>( EvalCharge( m_pxMETrack[m_muon1], m_pxMETrack[m_muon2] ) ) );
501  }
502  case CB:
503  {
504  return ( static_cast<int>( EvalCharge( m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] ) ) );
505  }
506  case ID:
507  {
508  return ( static_cast<int>( EvalCharge( m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] ) ) );
509  }
510  default:
511  return -999;
512  }
513 }

◆ getZEta()

const float& ZmumuEvent::getZEta ( ZTYPE  eType)
inline

Definition at line 83 of file ZmumuEvent.h.

83 { return m_fZEtaDir[eType]; }

◆ getZMass()

const float& ZmumuEvent::getZMass ( ZTYPE  eType)
inline

Definition at line 84 of file ZmumuEvent.h.

84 { return m_fInvariantMass[eType]; }

◆ getZPhi()

const float& ZmumuEvent::getZPhi ( ZTYPE  eType)
inline

Definition at line 85 of file ZmumuEvent.h.

85 { return m_fZPhiDir[eType]; }

◆ getZPt()

const float& ZmumuEvent::getZPt ( ZTYPE  eType)
inline

Definition at line 86 of file ZmumuEvent.h.

86 { return m_fZPt[eType]; }

◆ Init()

void ZmumuEvent::Init ( )
virtual

Reimplemented from EventAnalysis.

Definition at line 85 of file ZmumuEvent.cxx.

86 {
87  m_xMuonID.Init();
88 
89  PARENT::Init();
90 }

◆ OrderMuonList()

void ZmumuEvent::OrderMuonList ( )

Definition at line 633 of file ZmumuEvent.cxx.

634 {
635  int muPlusId = -9;
636  int muMinusId = -9;
637  double muPlusPt = 0.;
638  double muMinusPt = 0.;
639 
640  if (m_doDebug) {std::cout <<" * ZmumuEvent * OrderMuonList * START * input number of muons: " << m_numberOfFullPassMuons << std::endl;}
641 
642  if (m_numberOfFullPassMuons >= 2) {
643  for (int imuon=0; imuon < (int) m_numberOfFullPassMuons; imuon++) {
644  if (m_pxRecMuon[imuon] != nullptr) {
645 
646  if (m_pxRecMuon[imuon]->charge()== 1 && m_pxRecMuon[imuon]->pt()> muPlusPt) {
647  muPlusPt = m_pxRecMuon[imuon]->pt();
648  muPlusId = imuon;
649  }
650  if (m_pxRecMuon[imuon]->charge()==-1 && m_pxRecMuon[imuon]->pt()> muMinusPt) {
651  muMinusPt = m_pxRecMuon[imuon]->pt();
652  muMinusId = imuon;
653  }
654  } // muon exist
655  } // for (int imuon
656  } // if (m_numberOfFullPassMuons >= 2)
657  if (muPlusId>=0 && muMinusId>=0) {
658  m_muon1 = muPlusId;
659  m_muon2 = muMinusId;
660  m_numberOfFullPassMuons = 2; // the two muons have been selected. Let's pretend we have only two muons then.
661  }
662  if (m_doDebug) {std::cout <<" * ZmumuEvent * OrderMuonList * COMPLETED ** numberOfFullPassMuons: " << m_numberOfFullPassMuons
663  << " mu+: " << muPlusId << " mu-: " << muMinusId << std::endl;}
664  return;
665 }

◆ Reco()

bool ZmumuEvent::Reco ( int  theLumiBlock = 0)
virtual

Definition at line 111 of file ZmumuEvent.cxx.

112 {
113  if (m_doDebug) { std::cout << " * ZmumuEvent * ZmumuEvent::Reco() starting " << std::endl; }
114  m_analyzedEventCount++;
115 
116  // Clear out the previous events record.
117  this->Clear();
118 
119  // before getting into bsiness, check lumiblock is in requested range
120  if (m_maxGoodLumiBlock > m_minGoodLumiBlock) {
121  // lumiblock range is requested
122  if ( theLumiBlock < m_minGoodLumiBlock) return false;
123  if ( theLumiBlock > m_maxGoodLumiBlock) return false;
124  }
125  m_eventselectioncount_goodlumiblock++;
126 
127  // retrieve muons
128  const xAOD::MuonContainer* pxMuonContainer = PerfMonServices::getContainer<xAOD::MuonContainer>( m_container );
129 
130  // START patch by Anthony to avoid crash when MuonSpetrometer::Pt was not defined mainly for data16
131  // WARNING thus is necessary for data16 !!
132  if (false) {
133  for( auto muon : *pxMuonContainer ){
134  const xAOD::TrackParticle* idtrk(nullptr);
135  const xAOD::TrackParticle* metrk(nullptr);
136  idtrk = muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
137  metrk = muon->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
138  if (idtrk && metrk) {
139  static const SG::Decorator<float> InnerDetectorPtAcc("InnerDetectorPt");
140  static const SG::Decorator<float> MuonSpectrometerPtAcc("MuonSpectrometerPt");
141  InnerDetectorPtAcc(*muon) = idtrk->pt();
142  MuonSpectrometerPtAcc(*muon) = metrk->pt();
143  }
144  }
145  }
146  // END patch
147 
148  if (pxMuonContainer != nullptr) {
149  if (m_doDebug) {std::cout << " * ZmumuEvent * track list has "<< pxMuonContainer->size() << " muon in xAOD::MuonContainer " << m_container <<std::endl; }
150  xAOD::MuonContainer::const_iterator xMuonItr = pxMuonContainer->begin();
151  xAOD::MuonContainer::const_iterator xMuonItrE = pxMuonContainer->end();
152 
153  int attemptedMuonCount = 0;
154  int acceptedMuonCount = 0;
155 
156  while ( xMuonItr != xMuonItrE ){ // this loops on the muons in the pxMuonContainer
157  const xAOD::Muon* pxCMuon = *xMuonItr;
158  attemptedMuonCount++;
159  m_testedMuonCount++;
160  if(m_doDebug){std::cout << " * ZmumuEvent * Reco() ** attempt on xMuonItr number "<< attemptedMuonCount << " (pointer: "<< *xMuonItr <<")" << std::endl; }
161  // Apply muon cuts
162  if ( m_xMuonID.passSelection( pxCMuon) ) {
163  if (RecordMuon( pxCMuon )) {
164  acceptedMuonCount++;
165  m_acceptedMuonCount++;
166  if (m_doDebug) {std::cout << " This muon is accepeted !! this is muon number " << acceptedMuonCount << " & full pass" << m_numberOfFullPassMuons << std::endl; }
167  }
168  }
169  ++xMuonItr;
170  } // end loop on muons
171  if (m_doDebug) {std::cout << " * ZmumuEvent * accepted " << acceptedMuonCount << " muons from the input list of "<< pxMuonContainer->size() <<std::endl; }
172 
173  if (acceptedMuonCount < 2) m_eventsWithoutEnoughMuonsCount++;
174  if (acceptedMuonCount >= 2) m_eventsWithEnoughMuonsCount++;
175  } // muon container exist
176  else {
177  std::cout << " * ZmumuEvent * Can't retrieve combined muon collection (container: " << m_container <<") " << std::endl;
178  return false;
179  }
180 
181  // Ordering of muons
182  this->OrderMuonList();
183 
184  // Reconstruct the invariant mass ( based on mu-sys pt ).
185  ReconstructKinematics();
186 
187  m_passedSelectionCuts = EventSelection(ID);
188  m_DiMuonPairInvMass = m_fInvariantMass[ID];
189 
190  if (m_passedSelectionCuts) m_acceptedEventCount++;
191 
192  if(m_doDebug) {
193  if ( m_passedSelectionCuts) std::cout << " * ZmumuEvent * Reco() * result of analyzed event " << m_analyzedEventCount << " --> Selected event :) " << std::endl;
194  if (!m_passedSelectionCuts) std::cout << " * ZmumuEvent * Reco() * result of analyzed event " << m_analyzedEventCount << " --> Rejected event :( " << std::endl;
195  }
196  if (m_doDebug) {
197  std::cout << " * ZmumuEvent::Reco * COMPLETED * Event has " << m_numberOfFullPassMuons
198  << " muons. " << m_acceptedEventCount
199  << " events accpeted out of " << m_analyzedEventCount
200  << " tested ";
201  if (m_passedSelectionCuts) std::cout << " This m= " << m_DiMuonPairInvMass;
202  std::cout << " * return " << m_passedSelectionCuts << std::endl;
203  }
204  return m_passedSelectionCuts;
205 }

◆ ReconstructKinematics()

void ZmumuEvent::ReconstructKinematics ( )
private

Definition at line 429 of file ZmumuEvent.cxx.

430 {
431  // Three ways. No checks here. Thus make sure the pointers are ok before this.
432  if ( m_numberOfFullPassMuons == 2 )
433  {
434  // Note that all the util. functions will check the pointers & return -999.9f on failure.
435  m_fInvariantMass[MS] = EvalDiMuInvMass( m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
436  m_fMuonDispersion[MS] = EvaluateAngle( m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
437  m_fZPt[MS] = EvalPt( m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
438  m_fZEtaDir[MS] = EvalEta( m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
439  m_fZPhiDir[MS] = EvalPhi( m_pxMSTrack[m_muon1], m_pxMSTrack[m_muon2] );
440 
441  m_fInvariantMass[CB] = EvalDiMuInvMass( m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
442  m_fMuonDispersion[CB] = EvaluateAngle( m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
443  m_fZPt[CB] = EvalPt( m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
444  m_fZEtaDir[CB] = EvalEta( m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
445  m_fZPhiDir[CB] = EvalPhi( m_pxRecMuon[m_muon1], m_pxRecMuon[m_muon2] );
446 
447  m_fInvariantMass[ID] = EvalDiMuInvMass( m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2]);
448  m_fMuonDispersion[ID] = EvaluateAngle( m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] );
449  m_fZPt[ID] = EvalPt( m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] );
450  m_fZEtaDir[ID] = EvalEta( m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] );
451  m_fZPhiDir[ID] = EvalPhi( m_pxIDTrack[m_muon1], m_pxIDTrack[m_muon2] );
452  }
453 }

◆ RecordMuon()

bool ZmumuEvent::RecordMuon ( const xAOD::Muon *  pxMuon)
private

Definition at line 386 of file ZmumuEvent.cxx.

387 {
388  if(m_doDebug) { std::cout <<" * ZmumuEvent * RecordMuon * START ** muons recorded so far "<< m_numberOfFullPassMuons << " up to a maximum of " << NUM_MUONS << std::endl;}
389 
390  // This shouldn't really ever happen but just in case.
391  if ( !pxMuon ) {
392  if(m_doDebug) { std::cout <<" * ZmumuEvent * RecordMuon * bad pxMuon --> EXIT "<< std::endl;}
393  return false;
394  }
395 
396  if ( m_numberOfFullPassMuons < NUM_MUONS ) {
397  // The main Muon
398  m_pxRecMuon[m_numberOfFullPassMuons] = pxMuon;
399  // Tracking Muon Spectrometer ( raw )
400  const xAOD::TrackParticle* pxMSTrack = pxMuon->trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
401  if (!pxMSTrack) {
402  if(m_doDebug){ std::cout <<" * ZmumuEvent * RecordMuon * bad pxMSmuon --> EXIT "<< std::endl;}
403  return false;
404  }
405  m_pxMSTrack[m_numberOfFullPassMuons] = pxMSTrack;
406 
407  // Tracking ID ( fix later to include loose match track conditions )
408  const xAOD::TrackParticle* pxIDTrack = pxMuon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
409  if (!pxIDTrack) {
410  return false;
411  }
412  m_pxIDTrack[m_numberOfFullPassMuons] = pxIDTrack;
413  //
414  if(m_doDebug){ std::cout <<" m_pxRecMuon[" << m_numberOfFullPassMuons <<"]"
415  << " pt= " << m_pxRecMuon[m_numberOfFullPassMuons]->pt() << " q= "<< m_pxRecMuon[m_numberOfFullPassMuons]->charge() << std::endl;}
416  if(m_doDebug){ std::cout <<" m_pxMSTrack[" << m_numberOfFullPassMuons <<"]"
417  <<" pt= " << m_pxMSTrack[m_numberOfFullPassMuons]->pt() << " q= " << m_pxMSTrack[m_numberOfFullPassMuons]->charge() << std::endl;}
418  if(m_doDebug){ std::cout <<" m_pxIDTrack[" << m_numberOfFullPassMuons <<"]"
419  <<" pt= " << m_pxIDTrack[m_numberOfFullPassMuons]->pt() << " q= " << m_pxIDTrack[m_numberOfFullPassMuons]->charge() << std::endl;}
420  // update count
421  ++m_numberOfFullPassMuons;
422  }
423  if(m_doDebug){ std::cout <<" * ZmumuEvent * RecordMuon * return with a total of " << m_numberOfFullPassMuons << std::endl;}
424  return true;
425 }

◆ Register()

void EventAnalysis::Register ( )
privateinherited

Definition at line 64 of file EventAnalysis.cxx.

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

◆ setContainer()

void ZmumuEvent::setContainer ( PerfMonServices::CONTAINERS  container)
inline

Definition at line 102 of file ZmumuEvent.h.

102 { m_container = container; };

◆ setDebugMode()

void ZmumuEvent::setDebugMode ( bool  debug)
inline

Definition at line 88 of file ZmumuEvent.h.

88 { m_doDebug=debug; }

◆ SetLeadingMuonPtCut()

void ZmumuEvent::SetLeadingMuonPtCut ( double  newvalue)

Definition at line 600 of file ZmumuEvent.cxx.

601 {
602  // first set the new pt cut value
603  m_LeadingMuonPtCut = newvalue;
604 
605 
606  // the second muon pt cut can not be higher than the leading muon pt cut:
607  if (m_LeadingMuonPtCut < m_SecondMuonPtCut) this->SetSecondMuonPtCut(m_LeadingMuonPtCut);
608 
609  // this has to be translated to the MuonSelector
610  // but there one has to use the minimum momentum --> second muon
611  //this->SetMuonPtCut(m_SecondMuonPtCut);
612  if(m_doDebug && false){std::cout <<" * ZmumuEvent * SetLeadingMuonPtCut * new Pt cuts: " << m_LeadingMuonPtCut << " & " << m_SecondMuonPtCut << " MuonSelector: " << m_xMuonID.GetPtCut() << std::endl;}
613  return;
614 }

◆ SetMassWindowHigh()

void ZmumuEvent::SetMassWindowHigh ( double  newvalue)
inline

Definition at line 95 of file ZmumuEvent.h.

95 { m_MassWindowHigh = newvalue; }

◆ SetMassWindowLow()

void ZmumuEvent::SetMassWindowLow ( double  newvalue)
inline

Definition at line 94 of file ZmumuEvent.h.

94 { m_MassWindowLow = newvalue; }

◆ SetMaxLumiBlock()

void ZmumuEvent::SetMaxLumiBlock ( int  newlumiblock)
inline

Definition at line 89 of file ZmumuEvent.h.

89 { m_maxGoodLumiBlock = newlumiblock; }

◆ SetMinLumiBlock()

void ZmumuEvent::SetMinLumiBlock ( int  newlumiblock)
inline

Definition at line 90 of file ZmumuEvent.h.

90 { m_minGoodLumiBlock = newlumiblock; }

◆ SetMuonPtCut()

void ZmumuEvent::SetMuonPtCut ( double  newvalue)
inline

Definition at line 91 of file ZmumuEvent.h.

91 { m_xMuonID.SetPtCut(newvalue); }

◆ SetMuonQuality()

void ZmumuEvent::SetMuonQuality ( const std::string &  newname)
inline

Definition at line 92 of file ZmumuEvent.h.

92 { m_xMuonID.SetMuonQualityRequirement(newname); }

◆ SetMuonSelectionTool()

void ZmumuEvent::SetMuonSelectionTool ( ToolHandle< CP::IMuonSelectionTool >  mst)
inline

Definition at line 103 of file ZmumuEvent.h.

103 { m_muonSelectionTool = mst; m_xMuonID.SetCustomMuonSelectionTool (mst); };

◆ SetOpeningAngleCut()

void ZmumuEvent::SetOpeningAngleCut ( double  newvalue)
inline

Definition at line 98 of file ZmumuEvent.h.

98 {m_OpeningAngleCut = newvalue;}

◆ SetSecondMuonPtCut()

void ZmumuEvent::SetSecondMuonPtCut ( double  newvalue)

Definition at line 617 of file ZmumuEvent.cxx.

618 {
619  m_SecondMuonPtCut = newvalue;
620 
621  // second muon pt shouldn't be higher than the leading muon pt
622  if (m_LeadingMuonPtCut < m_SecondMuonPtCut) this->SetLeadingMuonPtCut(m_LeadingMuonPtCut);
623 
624  // this has to be translated to the MuonSelector
625  this->SetMuonPtCut(m_SecondMuonPtCut);
626 
627  if(m_doDebug && false){std::cout <<" * ZmumuEvent * SetSecondMuonPtCut * new Pt cuts: " << m_LeadingMuonPtCut << " & " << m_SecondMuonPtCut << " MuonSelector: " << m_xMuonID.GetPtCut() << std::endl;}
628 
629  return;
630 }

◆ SetSkipMSCheck()

void ZmumuEvent::SetSkipMSCheck ( bool  value)
inline

Definition at line 100 of file ZmumuEvent.h.

100 {m_skipMScheck = value;}

◆ SetZ0GapCut()

void ZmumuEvent::SetZ0GapCut ( double  newvalue)
inline

Definition at line 99 of file ZmumuEvent.h.

99 {m_Z0GapCut = newvalue;}

Member Data Documentation

◆ invalidAnswer

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

Definition at line 39 of file EventAnalysis.h.

◆ m_acceptedEventCount

unsigned int ZmumuEvent::m_acceptedEventCount {}
private

Definition at line 146 of file ZmumuEvent.h.

◆ m_acceptedMuonCount

unsigned int ZmumuEvent::m_acceptedMuonCount {}
private

Definition at line 148 of file ZmumuEvent.h.

◆ m_analyzedEventCount

int ZmumuEvent::m_analyzedEventCount {}
private

Definition at line 143 of file ZmumuEvent.h.

◆ m_bLooseMatch

bool ZmumuEvent::m_bLooseMatch
private

Definition at line 125 of file ZmumuEvent.h.

◆ m_container

PerfMonServices::CONTAINERS ZmumuEvent::m_container
private

Definition at line 119 of file ZmumuEvent.h.

◆ m_DiMuonPairInvMass

double ZmumuEvent::m_DiMuonPairInvMass = 0.0
private

Definition at line 127 of file ZmumuEvent.h.

◆ m_doDebug

bool ZmumuEvent::m_doDebug
private

Definition at line 139 of file ZmumuEvent.h.

◆ m_etaCut

double ZmumuEvent::m_etaCut
private

Definition at line 126 of file ZmumuEvent.h.

◆ m_eventselectioncount_dimuoncharge

unsigned int ZmumuEvent::m_eventselectioncount_dimuoncharge {}
private

Definition at line 156 of file ZmumuEvent.h.

◆ m_eventselectioncount_goodlumiblock

unsigned int ZmumuEvent::m_eventselectioncount_goodlumiblock {}
private

Definition at line 157 of file ZmumuEvent.h.

◆ m_eventselectioncount_masswindow

unsigned int ZmumuEvent::m_eventselectioncount_masswindow {}
private

Definition at line 154 of file ZmumuEvent.h.

◆ m_eventselectioncount_morethantwomuons

unsigned int ZmumuEvent::m_eventselectioncount_morethantwomuons {}
private

Definition at line 151 of file ZmumuEvent.h.

◆ m_eventselectioncount_notallmuonsfilled

unsigned int ZmumuEvent::m_eventselectioncount_notallmuonsfilled {}
private

Definition at line 150 of file ZmumuEvent.h.

◆ m_eventselectioncount_openingangle

unsigned int ZmumuEvent::m_eventselectioncount_openingangle {}
private

Definition at line 155 of file ZmumuEvent.h.

◆ m_eventselectioncount_ptofleadingmuon

unsigned int ZmumuEvent::m_eventselectioncount_ptofleadingmuon {}
private

Definition at line 152 of file ZmumuEvent.h.

◆ m_eventselectioncount_ptofsecondmuon

unsigned int ZmumuEvent::m_eventselectioncount_ptofsecondmuon {}
private

Definition at line 153 of file ZmumuEvent.h.

◆ m_eventselectioncount_toofewmuons

unsigned int ZmumuEvent::m_eventselectioncount_toofewmuons {}
private

Definition at line 149 of file ZmumuEvent.h.

◆ m_eventsWithEnoughMuonsCount

unsigned int ZmumuEvent::m_eventsWithEnoughMuonsCount {}
private

Definition at line 145 of file ZmumuEvent.h.

◆ m_eventsWithoutEnoughMuonsCount

unsigned int ZmumuEvent::m_eventsWithoutEnoughMuonsCount {}
private

Definition at line 144 of file ZmumuEvent.h.

◆ m_fInvariantMass

float ZmumuEvent::m_fInvariantMass[NUM_TYPES] {}
private

Definition at line 169 of file ZmumuEvent.h.

◆ m_fMuonDispersion

float ZmumuEvent::m_fMuonDispersion[NUM_TYPES] {}
private

Definition at line 170 of file ZmumuEvent.h.

◆ m_fZEtaDir

float ZmumuEvent::m_fZEtaDir[NUM_TYPES] {}
private

Definition at line 167 of file ZmumuEvent.h.

◆ m_fZPhiDir

float ZmumuEvent::m_fZPhiDir[NUM_TYPES] {}
private

Definition at line 168 of file ZmumuEvent.h.

◆ m_fZPt

float ZmumuEvent::m_fZPt[NUM_TYPES] {}
private

Definition at line 166 of file ZmumuEvent.h.

◆ m_LeadingMuonPtCut

double ZmumuEvent::m_LeadingMuonPtCut
private

Definition at line 129 of file ZmumuEvent.h.

◆ m_MassWindowHigh

double ZmumuEvent::m_MassWindowHigh
private

Definition at line 132 of file ZmumuEvent.h.

◆ m_MassWindowLow

double ZmumuEvent::m_MassWindowLow
private

Definition at line 131 of file ZmumuEvent.h.

◆ m_maxGoodLumiBlock

int ZmumuEvent::m_maxGoodLumiBlock
private

Definition at line 137 of file ZmumuEvent.h.

◆ m_minGoodLumiBlock

int ZmumuEvent::m_minGoodLumiBlock
private

Definition at line 136 of file ZmumuEvent.h.

◆ m_muon1

int ZmumuEvent::m_muon1 = 0
private

Definition at line 184 of file ZmumuEvent.h.

◆ m_muon2

int ZmumuEvent::m_muon2 = 0
private

Definition at line 185 of file ZmumuEvent.h.

◆ m_muonSelectionTool

ToolHandle<CP::IMuonSelectionTool> ZmumuEvent::m_muonSelectionTool
private

Definition at line 120 of file ZmumuEvent.h.

◆ m_numberOfFullPassMuons

unsigned int ZmumuEvent::m_numberOfFullPassMuons {}
private

Definition at line 141 of file ZmumuEvent.h.

◆ m_OpeningAngleCut

double ZmumuEvent::m_OpeningAngleCut
private

Definition at line 133 of file ZmumuEvent.h.

◆ m_passedSelectionCuts

bool ZmumuEvent::m_passedSelectionCuts {}
private

Definition at line 142 of file ZmumuEvent.h.

◆ m_pxIDTrack

const xAOD::TrackParticle* ZmumuEvent::m_pxIDTrack[NUM_MUONS] {}
private

Definition at line 163 of file ZmumuEvent.h.

◆ m_pxMETrack

const xAOD::TrackParticle* ZmumuEvent::m_pxMETrack[NUM_MUONS] {}
private

Definition at line 161 of file ZmumuEvent.h.

◆ m_pxMSTrack

const xAOD::TrackParticle* ZmumuEvent::m_pxMSTrack[NUM_MUONS] {}
private

Definition at line 162 of file ZmumuEvent.h.

◆ m_pxRecMuon

const xAOD::Muon* ZmumuEvent::m_pxRecMuon[NUM_MUONS] {}
private

Definition at line 160 of file ZmumuEvent.h.

◆ m_SecondMuonPtCut

double ZmumuEvent::m_SecondMuonPtCut
private

Definition at line 130 of file ZmumuEvent.h.

◆ m_SelectMuonByIP

bool ZmumuEvent::m_SelectMuonByIP
private

Definition at line 181 of file ZmumuEvent.h.

◆ m_SelectMuonByIso

bool ZmumuEvent::m_SelectMuonByIso
private

Definition at line 180 of file ZmumuEvent.h.

◆ m_skipMScheck

bool ZmumuEvent::m_skipMScheck
private

Definition at line 135 of file ZmumuEvent.h.

◆ m_testedMuonCount

unsigned int ZmumuEvent::m_testedMuonCount {}
private

Definition at line 147 of file ZmumuEvent.h.

◆ m_uMuonTags

unsigned int ZmumuEvent::m_uMuonTags
private

Definition at line 123 of file ZmumuEvent.h.

◆ m_uPassedEvents

unsigned int EventAnalysis::m_uPassedEvents
protectedinherited

Definition at line 74 of file EventAnalysis.h.

◆ m_uTrackMatch

unsigned int ZmumuEvent::m_uTrackMatch
private

Definition at line 124 of file ZmumuEvent.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_xMuonID

MuonSelector ZmumuEvent::m_xMuonID
private

Definition at line 118 of file ZmumuEvent.h.

◆ m_xSampleName

std::string EventAnalysis::m_xSampleName
protectedinherited

Definition at line 80 of file EventAnalysis.h.

◆ m_Z0GapCut

double ZmumuEvent::m_Z0GapCut
private

Definition at line 134 of file ZmumuEvent.h.

The documentation for this class was generated from the following files:
ZmumuEvent::m_fZPhiDir
float m_fZPhiDir[NUM_TYPES]
Definition: ZmumuEvent.h:168
EventAnalysis::EvalInvMass
static float EvalInvMass(const T *pxP1, const T *pxP2, float fMass1, float fMass2=invalidAnswer)
Definition: EventAnalysis.h:106
ZmumuEvent::m_minGoodLumiBlock
int m_minGoodLumiBlock
Definition: ZmumuEvent.h:136
EventAnalysis::EvaluateAngle
static float EvaluateAngle(const T *pxP1, const T *pxP2)
Definition: EventAnalysis.h:163
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
ZmumuEvent::m_fZPt
float m_fZPt[NUM_TYPES]
Definition: ZmumuEvent.h:166
ZmumuEvent::UNDEF
@ UNDEF
Definition: ZmumuEvent.h:47
ParticleGun_SamplingFraction.eta2
eta2
Definition: ParticleGun_SamplingFraction.py:96
ZmumuEvent::m_pxIDTrack
const xAOD::TrackParticle * m_pxIDTrack[NUM_MUONS]
Definition: ZmumuEvent.h:163
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
ZmumuEvent::FORWARD
@ FORWARD
Definition: ZmumuEvent.h:45
ZmumuEvent::m_numberOfFullPassMuons
unsigned int m_numberOfFullPassMuons
Definition: ZmumuEvent.h:141
ZmumuEvent::m_LeadingMuonPtCut
double m_LeadingMuonPtCut
Definition: ZmumuEvent.h:129
ID
std::vector< Identifier > ID
Definition: CalibHitIDCheck.h:24
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
xAOD::Muon_v1::trackParticle
const TrackParticle * trackParticle(TrackParticleType type) const
Returns a pointer (which can be NULL) to the TrackParticle used in identification of this muon.
Definition: Muon_v1.cxx:504
perp
Scalar perp() const
perp method - perpenticular length
Definition: AmgMatrixBasePlugin.h:35
ZmumuEvent::m_uTrackMatch
unsigned int m_uTrackMatch
Definition: ZmumuEvent.h:124
xAOD::TrackParticle_v1::charge
float charge() const
Returns the charge.
Definition: TrackParticle_v1.cxx:150
ZmumuEvent::MUON2
@ MUON2
Definition: ZmumuEvent.h:36
ZmumuEvent::Clear
void Clear()
Definition: ZmumuEvent.cxx:361
EventAnalysis::EvalDiMuInvMass
static float EvalDiMuInvMass(const T *pxP1, const T *pxP2)
Definition: EventAnalysis.h:97
ZmumuEvent::m_fZEtaDir
float m_fZEtaDir[NUM_TYPES]
Definition: ZmumuEvent.h:167
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
ZmumuEvent::m_Z0GapCut
double m_Z0GapCut
Definition: ZmumuEvent.h:134
ZmumuEvent::m_eventselectioncount_ptofleadingmuon
unsigned int m_eventselectioncount_ptofleadingmuon
Definition: ZmumuEvent.h:152
ZmumuEvent::m_acceptedMuonCount
unsigned int m_acceptedMuonCount
Definition: ZmumuEvent.h:148
xAOD::TrackParticle_v1::vz
float vz() const
The z origin for the parameters.
ZmumuEvent::m_eventselectioncount_masswindow
unsigned int m_eventselectioncount_masswindow
Definition: ZmumuEvent.h:154
ZmumuEvent::m_pxRecMuon
const xAOD::Muon * m_pxRecMuon[NUM_MUONS]
Definition: ZmumuEvent.h:160
ZmumuEvent::MS
@ MS
Definition: ZmumuEvent.h:52
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
ZmumuEvent::MUON1
@ MUON1
Definition: ZmumuEvent.h:35
PerfMonServices::MUID_COLLECTION
@ MUID_COLLECTION
Definition: PerfMonServices.h:43
ZmumuEvent::m_uMuonTags
unsigned int m_uMuonTags
Definition: ZmumuEvent.h:123
athena.value
value
Definition: athena.py:122
xAOD::eta1
setEt setPhi setE277 setWeta2 eta1
Definition: TrigEMCluster_v1.cxx:41
ZmumuEvent::m_MassWindowHigh
double m_MassWindowHigh
Definition: ZmumuEvent.h:132
ZmumuEvent::m_eventselectioncount_goodlumiblock
unsigned int m_eventselectioncount_goodlumiblock
Definition: ZmumuEvent.h:157
ZmumuEvent::m_doDebug
bool m_doDebug
Definition: ZmumuEvent.h:139
ZmumuEvent::EventSelection
bool EventSelection(ZTYPE eType)
Definition: ZmumuEvent.cxx:218
EventAnalysis::EvalCharge
static float EvalCharge(const T *pxP1, const T *pxP2)
Definition: EventAnalysis.h:238
ZmumuEvent::m_OpeningAngleCut
double m_OpeningAngleCut
Definition: ZmumuEvent.h:133
ZmumuEvent::ME
@ ME
Definition: ZmumuEvent.h:53
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:83
EventAnalysis::m_x1DHistograms
std::map< unsigned int, TH1F * > m_x1DHistograms
Definition: EventAnalysis.h:75
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
ZmumuEvent::m_muon1
int m_muon1
Definition: ZmumuEvent.h:184
ZmumuEvent::m_bLooseMatch
bool m_bLooseMatch
Definition: ZmumuEvent.h:125
ZmumuEvent::SetMuonPtCut
void SetMuonPtCut(double newvalue)
Definition: ZmumuEvent.h:91
xAOD::Muon_v1::charge
float charge() const
ZmumuEvent::m_testedMuonCount
unsigned int m_testedMuonCount
Definition: ZmumuEvent.h:147
ZmumuEvent::m_fMuonDispersion
float m_fMuonDispersion[NUM_TYPES]
Definition: ZmumuEvent.h:170
MuonSelector::SetCustomMuonSelectionTool
void SetCustomMuonSelectionTool(ToolHandle< CP::IMuonSelectionTool > mst)
Definition: MuonSelector.h:58
ZmumuEvent::NUM_MUONS
@ NUM_MUONS
Definition: ZmumuEvent.h:39
EventAnalysis::m_x2DHistograms
std::map< unsigned int, TH2F * > m_x2DHistograms
Definition: EventAnalysis.h:76
ZmumuEvent::ZMASS_TRACK
@ ZMASS_TRACK
Definition: ZmumuEvent.h:175
ZmumuEvent::m_container
PerfMonServices::CONTAINERS m_container
Definition: ZmumuEvent.h:119
ZmumuEvent::m_passedSelectionCuts
bool m_passedSelectionCuts
Definition: ZmumuEvent.h:142
EventAnalysis::EvalTransverseMass
static float EvalTransverseMass(const T *pxP1, float fMETx, float fMETy, float fMass1, float fMass2=invalidAnswer)
Definition: EventAnalysis.h:254
SG::Decorator< float >
EventAnalysis::calculateMomentum
static CLHEP::Hep3Vector calculateMomentum(const T *pP)
Definition: EventAnalysis.h:91
MuonSelector::doMCPSelection
void doMCPSelection(bool domcp)
Definition: MuonSelector.h:52
EventAnalysis::EvalPtDiff
static float EvalPtDiff(const T *pxP1, const T *pxP2)
Definition: EventAnalysis.h:173
ZmumuEvent::m_eventselectioncount_morethantwomuons
unsigned int m_eventselectioncount_morethantwomuons
Definition: ZmumuEvent.h:151
ZmumuEvent::m_skipMScheck
bool m_skipMScheck
Definition: ZmumuEvent.h:135
ZmumuEvent::m_SecondMuonPtCut
double m_SecondMuonPtCut
Definition: ZmumuEvent.h:130
ZmumuEvent::m_fInvariantMass
float m_fInvariantMass[NUM_TYPES]
Definition: ZmumuEvent.h:169
ZmumuEvent::m_SelectMuonByIP
bool m_SelectMuonByIP
Definition: ZmumuEvent.h:181
ZmumuEvent::m_pxMETrack
const xAOD::TrackParticle * m_pxMETrack[NUM_MUONS]
Definition: ZmumuEvent.h:161
MuonSelector::doIsoSelection
void doIsoSelection(bool doIso)
Definition: MuonSelector.h:50
ZmumuEvent::ZMASS_MUON
@ ZMASS_MUON
Definition: ZmumuEvent.h:175
MuonSelector::Init
virtual void Init()
Definition: MuonSelector.cxx:113
ZmumuEvent::m_muonSelectionTool
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition: ZmumuEvent.h:120
MuonSegmentReaderConfig.histSvc
histSvc
Definition: MuonSegmentReaderConfig.py:96
ZmumuEvent::NUM_TYPES
@ NUM_TYPES
Definition: ZmumuEvent.h:56
xAOD::Muon_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
ZmumuEvent::m_DiMuonPairInvMass
double m_DiMuonPairInvMass
Definition: ZmumuEvent.h:127
MuonSelector::GetPtCut
double GetPtCut()
Definition: MuonSelector.h:55
ZmumuEvent::BACKWARD
@ BACKWARD
Definition: ZmumuEvent.h:46
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
MuonSelector::SetMuonQualityRequirement
void SetMuonQualityRequirement(std::string newname)
Definition: MuonSelector.cxx:478
ZmumuEvent::m_acceptedEventCount
unsigned int m_acceptedEventCount
Definition: ZmumuEvent.h:146
ZmumuEvent::RecordMuon
bool RecordMuon(const xAOD::Muon *pxMuon)
Definition: ZmumuEvent.cxx:386
ZmumuEvent::ID
@ ID
Definition: ZmumuEvent.h:54
EventAnalysis::m_x1DProfHistograms
std::map< unsigned int, TProfile * > m_x1DProfHistograms
Definition: EventAnalysis.h:77
ZmumuEvent::m_eventsWithEnoughMuonsCount
unsigned int m_eventsWithEnoughMuonsCount
Definition: ZmumuEvent.h:145
ZmumuEvent::m_eventselectioncount_openingangle
unsigned int m_eventselectioncount_openingangle
Definition: ZmumuEvent.h:155
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
ZmumuEvent::CENTRAL
@ CENTRAL
Definition: ZmumuEvent.h:44
ZmumuEvent::m_analyzedEventCount
int m_analyzedEventCount
Definition: ZmumuEvent.h:143
charge
double charge(const T &p)
Definition: AtlasPID.h:494
EventAnalysis::EvalEta
static float EvalEta(const T *pxP1, const T *pxP2)
Definition: EventAnalysis.h:229
ZmumuEvent::m_xMuonID
MuonSelector m_xMuonID
Definition: ZmumuEvent.h:118
ZmumuEvent::m_eventselectioncount_toofewmuons
unsigned int m_eventselectioncount_toofewmuons
Definition: ZmumuEvent.h:149
MuonSelector::passSelection
bool passSelection(const xAOD::Muon *pxMuon)
Definition: MuonSelector.cxx:146
EventAnalysis::EvalPt
static float EvalPt(const T *pxP1, const T *pxP2)
Definition: EventAnalysis.h:211
ZmumuEvent::m_eventsWithoutEnoughMuonsCount
unsigned int m_eventsWithoutEnoughMuonsCount
Definition: ZmumuEvent.h:144
ZmumuEvent::SetSecondMuonPtCut
void SetSecondMuonPtCut(double newvalue)
Definition: ZmumuEvent.cxx:617
MuonSelector::SetPtCut
void SetPtCut(double newvalue)
Definition: MuonSelector.h:54
ZmumuEvent::ReconstructKinematics
void ReconstructKinematics()
Definition: ZmumuEvent.cxx:429
python.PyAthena.v
v
Definition: PyAthena.py:157
ZmumuEvent::SetLeadingMuonPtCut
void SetLeadingMuonPtCut(double newvalue)
Definition: ZmumuEvent.cxx:600
MuonSelector::doIPSelection
void doIPSelection(bool doIPsel)
Definition: MuonSelector.h:51
EventAnalysis::m_x2DProfHistograms
std::map< unsigned int, TProfile2D * > m_x2DProfHistograms
Definition: EventAnalysis.h:78
ZmumuEvent::CB
@ CB
Definition: ZmumuEvent.h:55
ZmumuEvent::m_eventselectioncount_ptofsecondmuon
unsigned int m_eventselectioncount_ptofsecondmuon
Definition: ZmumuEvent.h:153
EAna::g_fMuonMass
const float g_fMuonMass
Definition: EventAnalysis.h:26
ZmumuEvent::m_pxMSTrack
const xAOD::TrackParticle * m_pxMSTrack[NUM_MUONS]
Definition: ZmumuEvent.h:162
ZmumuEvent::MUON4_OVR2
@ MUON4_OVR2
Definition: ZmumuEvent.h:38
ZmumuEvent::NUM_1HISTOS
@ NUM_1HISTOS
Definition: ZmumuEvent.h:176
ZmumuEvent::m_eventselectioncount_dimuoncharge
unsigned int m_eventselectioncount_dimuoncharge
Definition: ZmumuEvent.h:156
ZmumuEvent::OrderMuonList
void OrderMuonList()
Definition: ZmumuEvent.cxx:633
ZmumuEvent::m_MassWindowLow
double m_MassWindowLow
Definition: ZmumuEvent.h:131
EventAnalysis::EvalPhi
static float EvalPhi(const T *pxP1, const T *pxP2)
Definition: EventAnalysis.h:220
createCoolChannelIdFile.newname
newname
Definition: createCoolChannelIdFile.py:106
ZmumuEvent::getZCharge
int getZCharge(ZTYPE eType)
Definition: ZmumuEvent.cxx:490
ZmumuEvent::ZMASS_COMB
@ ZMASS_COMB
Definition: ZmumuEvent.h:175
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
ZmumuEvent::m_SelectMuonByIso
bool m_SelectMuonByIso
Definition: ZmumuEvent.h:180
ZmumuEvent::m_maxGoodLumiBlock
int m_maxGoodLumiBlock
Definition: ZmumuEvent.h:137
ZmumuEvent::MUON3_OVR1
@ MUON3_OVR1
Definition: ZmumuEvent.h:37
EventAnalysis::Init
virtual void Init()
Definition: EventAnalysis.cxx:45
EventAnalysis::m_xSampleName
std::string m_xSampleName
Definition: EventAnalysis.h:80
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
EAna::CGeV
const float CGeV
Definition: EventAnalysis.h:28
ZmumuEvent::getPosMuon
unsigned int getPosMuon(ZTYPE eType)
Definition: ZmumuEvent.cxx:516
ZmumuEvent::getNumberOfTaggedMuons
unsigned int getNumberOfTaggedMuons()
Definition: ZmumuEvent.h:77
ZmumuEvent::m_eventselectioncount_notallmuonsfilled
unsigned int m_eventselectioncount_notallmuonsfilled
Definition: ZmumuEvent.h:150
EventAnalysis::invalidAnswer
static constexpr float invalidAnswer
Definition: EventAnalysis.h:39
ZmumuEvent::m_muon2
int m_muon2
Definition: ZmumuEvent.h:185
ZmumuEvent::ZMASS_MUONADJ
@ ZMASS_MUONADJ
Definition: ZmumuEvent.h:175
ZmumuEvent::m_etaCut
double m_etaCut
Definition: ZmumuEvent.h:126
MuonSelector::finalize
virtual void finalize()
Definition: MuonSelector.cxx:461
ServiceHandle< ITHistSvc >
Generated on Fri Jul 5 2024 22:10:53 for ATLAS Offline Software by   doxygen 1.8.18