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

#include <IDPerfMonZmumu.h>

Inheritance diagram for IDPerfMonZmumu:
Collaboration diagram for IDPerfMonZmumu:

Public Member Functions

 IDPerfMonZmumu (const std::string &name, ISvcLocator *pSvcLocator)
 needed for IP resolution studies More...
 
 ~IDPerfMonZmumu ()
 
virtual StatusCode initialize ()
 
virtual StatusCode execute ()
 
virtual StatusCode finalize ()
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode bookTrees ()
 
StatusCode CheckTriggerStatusAndPrescale ()
 
void Clear4MuNtupleVariables ()
 
void ExtractIDHitsInformation (const xAOD::Muon *muon_pos, const xAOD::Muon *muon_neg)
 
int GetMuonQualityValue (std::string qualityname)
 
void RegisterHistograms ()
 
void ResetCommonNtupleVectors ()
 
const xAOD::Vertex * GetDiMuonVertex (const xAOD::TrackParticle *, const xAOD::TrackParticle *)
 
StatusCode FillRecParameters (const Trk::Track *track, const xAOD::TrackParticle *trackp_for_unbias, double charge, const xAOD::Vertex *vertex, const EventContext &ctx)
 
StatusCode FillRecParametersSimple (const Trk::Track *track, float charge, const xAOD::Vertex *vertex)
 
StatusCode FillRecParametersTP (const xAOD::TrackParticle *trackp, const xAOD::TrackParticle *trackp_for_unbias, double charge, const xAOD::Vertex *vertex=nullptr)
 
StatusCode FillTruthParameters (const xAOD::TrackParticle *track)
 
const xAOD::TruthParticle * getTruthParticle (const xAOD::IParticle &p)
 
StatusCode RunFourLeptonAnalysis ()
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

ZmumuEvent m_xZmm
 
FourMuonEvent m_4mu
 
bool m_UseTrigger
 
bool m_doIsoSelection
 
bool m_doIPSelection
 
bool m_doMCPSelection
 
double m_MassWindowLow
 
double m_MassWindowHigh
 
double m_LeadingMuonPtCut
 
double m_SecondMuonPtCut
 
double m_OpeningAngleCut
 
double m_Z0GapCut
 
bool m_isMC
 
bool m_doRefit
 
bool m_useTrackSelectionTool
 
bool m_doIP
 
bool m_doFourMuAnalysis
 
bool m_storeZmumuNtuple
 
bool m_skipMS
 
bool m_useCustomMuonSelector
 
int m_minGoodLumiBlock
 
int m_maxGoodLumiBlock
 
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter1
 The track refitter. More...
 
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter2
 The track refitter. More...
 
ToolHandle< Reco::ITrackToVertex > m_trackToVertexTool
 tool to extrapolate tracks to BL More...
 
ToolHandle< Trig::TrigDecisionTool > m_triggerDecision
 
ToolHandle< Trig::IMatchingTool > m_triggerMatching
 
ToolHandle< InDet::IInDetTrackSelectionTool > m_selTool
 The track selection Tool. More...
 
ToolHandle< Trk::ITrackToVertexIPEstimator > m_trackToVertexIPEstimator
 Needed for IP resolution studies. More...
 
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
 used for truth parameters More...
 
ToolHandle< Trk::IExtrapolator > m_extrapolator
 
ToolHandle< CP::IMuonSelectionTool > m_muonSelector
 used to pass a custom muon selector More...
 
bool m_validationMode
 < boolean to switch to validation mode More...
 
std::string m_commonTreeName
 
std::string m_defaultTreeName
 
std::string m_IDTreeName
 
std::string m_refit1TreeName
 
std::string m_refit2TreeName
 
std::string m_truthTreeName
 
std::string m_combTreeName
 
std::string m_MSTreeName
 
std::string m_FourMuTreeName
 
std::string m_ValidationTreeDescription
 < validation tree description - second argument in TTree More...
 
std::string m_commonTreeFolder
 
std::string m_defaultTreeFolder
 
std::string m_IDTreeFolder
 
std::string m_refit1TreeFolder
 
std::string m_refit2TreeFolder
 
std::string m_truthTreeFolder
 
std::string m_combTreeFolder
 
std::string m_MSTreeFolder
 
std::string m_FourMuTreeFolder
 Root Validation Tree. More...
 
TTree * m_commonTree
 
TTree * m_defaultTree
 
TTree * m_IDTree
 
TTree * m_refit1Tree
 
TTree * m_refit2Tree
 
TTree * m_truthTree
 
TTree * m_combTree
 
TTree * m_MSTree
 
TTree * m_FourMuTree
 
bool m_doRemoval {}
 
bool m_doDebug {}
 
ToolHandle< CP::ITrackVertexAssociationTool > m_Trk2VtxAssociationTool
 
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexKey { this, "VertexContainer", "PrimaryVertices", "primary vertex container" }
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackContainerName {this, "trackContainerName", "InDetTrackParticles"}
 IDTtacks. More...
 
std::string m_truthName
 
std::string m_trackParticleName
 Track(Particle)TruthCollection input name. More...
 
std::string m_truthLinkVecName
 TrackParticle input name. More...
 
TH1F * m_h_cutflow
 link vector to map HepMC onto xAOD truth More...
 
unsigned int m_runNumber {}
 
unsigned int m_evtNumber {}
 
unsigned int m_lumi_block {}
 
unsigned int m_event_mu {}
 
int m_triggerPrescale
 
std::string m_triggerName
 
unsigned int m_nVertex {}
 
double m_positive_px {}
 
double m_positive_py {}
 
double m_positive_pt {}
 
double m_positive_pz {}
 
double m_positive_phi {}
 
double m_positive_eta {}
 
double m_positive_z0 {}
 
double m_positive_d0 {}
 
double m_positive_z0_manualBS {}
 
double m_positive_d0_manualBS {}
 
double m_positive_z0_err {}
 
double m_positive_d0_err {}
 
double m_positive_sigma_pt {}
 
double m_positive_z0_PV {}
 
double m_positive_d0_PV {}
 
double m_positive_z0_PVerr {}
 
double m_positive_d0_PVerr {}
 
double m_positive_qoverp {}
 
double m_positive_sigma_qoverp {}
 
int m_positive_1_vtx {}
 
int m_positive_parent {}
 
double m_positive_2_px {}
 
double m_positive_2_py {}
 
double m_positive_2_pz {}
 
double m_positive_2_z0 {}
 
double m_positive_2_d0 {}
 
double m_positive_2_z0_err {}
 
double m_positive_2_d0_err {}
 
double m_positive_2_z0_PV {}
 
double m_positive_2_d0_PV {}
 
double m_positive_2_z0_PVerr {}
 
double m_positive_2_d0_PVerr {}
 
int m_positive_2_vtx {}
 
double m_negative_px {}
 
double m_negative_py {}
 
double m_negative_pt {}
 
double m_negative_pz {}
 
double m_negative_phi {}
 
double m_negative_eta {}
 
double m_negative_z0 {}
 
double m_negative_d0 {}
 
double m_negative_z0_manualBS {}
 
double m_negative_d0_manualBS {}
 
double m_negative_z0_err {}
 
double m_negative_d0_err {}
 
double m_negative_sigma_pt {}
 
double m_negative_z0_PV {}
 
double m_negative_d0_PV {}
 
double m_negative_z0_PVerr {}
 
double m_negative_d0_PVerr {}
 
double m_negative_qoverp {}
 
double m_negative_sigma_qoverp {}
 
int m_negative_1_vtx {}
 
int m_negative_parent {}
 
double m_negative_2_px {}
 
double m_negative_2_py {}
 
double m_negative_2_pz {}
 
double m_negative_2_z0 {}
 
double m_negative_2_d0 {}
 
double m_negative_2_z0_err {}
 
double m_negative_2_d0_err {}
 
double m_negative_2_z0_PV {}
 
double m_negative_2_d0_PV {}
 
double m_negative_2_z0_PVerr {}
 
double m_negative_2_d0_PVerr {}
 
int m_negative_2_vtx {}
 
double m_el_negative1_px {}
 
double m_el_negative1_py {}
 
double m_el_negative1_pz {}
 
double m_el_negative1_z0 {}
 
double m_el_negative1_d0 {}
 
double m_el_negative1_z0_err {}
 
double m_el_negative1_d0_err {}
 
double m_el_negative1_z0_PV {}
 
double m_el_negative1_d0_PV {}
 
double m_el_negative1_z0_PVerr {}
 
double m_el_negative1_d0_PVerr {}
 
int m_el_negative1_vtx {}
 
double m_el_negative2_px {}
 
double m_el_negative2_py {}
 
double m_el_negative2_pz {}
 
double m_el_negative2_z0 {}
 
double m_el_negative2_d0 {}
 
double m_el_negative2_z0_err {}
 
double m_el_negative2_d0_err {}
 
double m_el_negative2_z0_PV {}
 
double m_el_negative2_d0_PV {}
 
double m_el_negative2_z0_PVerr {}
 
double m_el_negative2_d0_PVerr {}
 
int m_el_negative2_vtx {}
 
double m_el_positive1_px {}
 
double m_el_positive1_py {}
 
double m_el_positive1_pz {}
 
double m_el_positive1_z0 {}
 
double m_el_positive1_d0 {}
 
double m_el_positive1_z0_err {}
 
double m_el_positive1_d0_err {}
 
double m_el_positive1_z0_PV {}
 
double m_el_positive1_d0_PV {}
 
double m_el_positive1_z0_PVerr {}
 
double m_el_psoitive1_d0_PVerr {}
 
int m_el_positive1_vtx {}
 
double m_el_positive2_px {}
 
double m_el_positive2_py {}
 
double m_el_positive2_pz {}
 
double m_el_positive2_z0 {}
 
double m_el_positive2_d0 {}
 
double m_el_positive2_z0_err {}
 
double m_el_positive2_d0_err {}
 
double m_el_positive2_z0_PV {}
 
double m_el_positive2_d0_PV {}
 
double m_el_positive2_z0_PVerr {}
 
double m_el_psoitive2_d0_PVerr {}
 
int m_el_positive2_vtx {}
 
double m_4mu_minv {}
 
double m_pv_x {}
 
double m_pv_y {}
 
double m_pv_z {}
 
unsigned int m_nTrkInVtx {}
 
double m_met {}
 
double m_metphi {}
 
std::vector< float > m_IDTrack_pt
 
std::vector< float > m_CBTrack_pt
 
std::vector< float > m_Refit1_pt
 
std::vector< float > m_Refit2_pt
 
std::vector< float > m_Truth_pt
 
std::vector< float > m_IDTrack_eta
 
std::vector< float > m_CBTrack_eta
 
std::vector< float > m_Refit1_eta
 
std::vector< float > m_Refit2_eta
 
std::vector< float > m_Truth_eta
 
std::vector< float > m_IDTrack_phi
 
std::vector< float > m_CBTrack_phi
 
std::vector< float > m_Refit1_phi
 
std::vector< float > m_Refit2_phi
 
std::vector< float > m_Truth_phi
 
std::vector< float > m_IDTrack_d0
 
std::vector< float > m_CBTrack_d0
 
std::vector< float > m_Refit1_d0
 
std::vector< float > m_Refit2_d0
 
std::vector< float > m_Truth_d0
 
std::vector< float > m_IDTrack_z0
 
std::vector< float > m_CBTrack_z0
 
std::vector< float > m_Refit1_z0
 
std::vector< float > m_Refit2_z0
 
std::vector< float > m_Truth_z0
 
std::vector< float > m_IDTrack_qoverp
 
std::vector< float > m_CBTrack_qoverp
 
std::vector< float > m_Refit1_qoverp
 
std::vector< float > m_Refit2_qoverp
 
std::vector< float > m_Truth_qoverp
 
std::vector< int > m_Truth_parent
 
std::vector< float > m_IDTrack_sigma_pt
 
std::vector< float > m_CBTrack_sigma_pt
 
std::vector< float > m_Refit1_sigma_pt
 
std::vector< float > m_Refit2_sigma_pt
 
std::vector< float > m_IDTrack_sigma_d0
 
std::vector< float > m_CBTrack_sigma_d0
 
std::vector< float > m_Refit1_sigma_d0
 
std::vector< float > m_Refit2_sigma_d0
 
std::vector< float > m_IDTrack_sigma_z0
 
std::vector< float > m_CBTrack_sigma_z0
 
std::vector< float > m_Refit1_sigma_z0
 
std::vector< float > m_Refit2_sigma_z0
 
std::vector< float > m_IDTrack_sigma_qoverp
 
std::vector< float > m_CBTrack_sigma_qoverp
 
std::vector< float > m_Refit1_sigma_qoverp
 
std::vector< float > m_Refit2_sigma_qoverp
 
std::vector< int > m_nBLhits
 
std::vector< int > m_nPIXhits
 
std::vector< int > m_nSCThits
 
std::vector< int > m_nTRThits
 
std::string m_sTriggerChainName
 
std::string m_outputTracksName
 
std::string m_MuonQualityName
 
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey {this, "EventInfoKey", "EventInfo"}
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 73 of file IDPerfMonZmumu.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ IDPerfMonZmumu()

IDPerfMonZmumu::IDPerfMonZmumu ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

needed for IP resolution studies

missing ET

Definition at line 47 of file IDPerfMonZmumu.cxx.

48  :
49  AthAlgorithm(name, pSvcLocator),
50  m_isMC(false),
51  m_doRefit(false),
52  m_TrackRefitter1(""),
53  m_TrackRefitter2(""),
54  m_trackToVertexTool("Reco::TrackToVertex"),
55  m_triggerDecision("Trig::TrigDecisionTool/TrigDecisionTool"),
56  m_triggerMatching("Trig::MatchingTool/MatchingTool"),
57  m_selTool( "InDet::InDetTrackSelectionTool/TrackSelectionTool"),
58  m_trackToVertexIPEstimator("Trk::TrackToVertexIPEstimator"),
59  m_extrapolator("Trk::Extrapolator/AtlasExtrapolator"),
60  m_muonSelector("CP::MuonSelectionTool/MuonSelectionTool"),
61  m_validationMode(true),
62 
63  m_commonTreeName ("commonTree"),
64  m_defaultTreeName("Default_Particle"),
65  m_IDTreeName ("ID_InDetTrackParticle"),
66  m_refit1TreeName ("Refit1_SiAndTRT"),
67  m_refit2TreeName ("Refit2_SiOnly"),
68  m_truthTreeName ("TruthParams"),
69  m_combTreeName ("CombinedTrackParticle"),
70  m_MSTreeName ("MS_TrackParticle"),
71  m_FourMuTreeName ("FourMu"),
72 
73  m_ValidationTreeDescription("Small Tree for Zmumu fits"),
74 
75  m_commonTreeFolder ("/ZmumuValidation/common"),
76  m_defaultTreeFolder("/ZmumuValidation/default"),
77  m_IDTreeFolder ("/ZmumuValidation/ID"),
78  m_refit1TreeFolder ("/ZmumuValidation/refit1"),
79  m_refit2TreeFolder ("/ZmumuValidation/refit2"),
80  m_truthTreeFolder ("/ZmumuValidation/truth"),
81  m_combTreeFolder ("/ZmumuValidation/comb"),
82  m_MSTreeFolder ("/ZmumuValidation/ms"),
83  m_FourMuTreeFolder ("/ZmumuValidation/fourmu"),
84 
85  m_commonTree (nullptr),
86  m_defaultTree(nullptr),
87  m_IDTree(nullptr),
88  m_refit1Tree(nullptr),
89  m_refit2Tree(nullptr),
90  m_truthTree(nullptr),
91  m_combTree(nullptr),
92  m_MSTree(nullptr),
93  m_FourMuTree(nullptr),
94  m_doRemoval(true),
95  m_doDebug(false),
96  m_Trk2VtxAssociationTool("CP::TrackVertexAssociationTool", this)
97 {
98  // Properties that are set from the python scripts.
99 
100  declareProperty("UseTrigger" , m_UseTrigger = true);
101  declareProperty("doIsoSelection", m_doIsoSelection = true );
102  declareProperty("doIPSelection", m_doIPSelection = true );
103  declareProperty("doMCPSelection", m_doMCPSelection = true );
104  declareProperty("isMC", m_isMC = false);
105  declareProperty("doRefit", m_doRefit = false);
106  declareProperty("doIPextrToPV", m_doIP = false);
107  declareProperty("Extrapolator", m_extrapolator );
108  declareProperty("MassWindowLow", m_MassWindowLow = 60.0, "Lower cut in mu+mu- invariant mass" );
109  declareProperty("MassWindowHigh", m_MassWindowHigh = 120.0, "Upper cut in mu+mu- invariant mass" );
110  declareProperty("OpeningAngle", m_OpeningAngleCut = 0.2, "Opening angle between the two muons (in radians)");
111  declareProperty("OutputTracksName", m_outputTracksName = "ZmumuTracks");
112  declareProperty("PtLeadingMuon", m_LeadingMuonPtCut = 20., "Pt cut on the leading muon");
113  declareProperty("PtSecondMuon", m_SecondMuonPtCut = 15., "Pt cut on the second muon");
114  declareProperty("ReFitterTool1", m_TrackRefitter1, "ToolHandle for track fitter implementation");
115  declareProperty("ReFitterTool2", m_TrackRefitter2, "ToolHandle for track fitter implementation");
116  declareProperty("TrackToVertexTool", m_trackToVertexTool);
117  declareProperty("TrackTruthName", m_truthName="TrackTruthCollection");
118  declareProperty("TrackParticleName", m_trackParticleName="CombinedTrackParticle");
119  declareProperty("triggerChainName", m_sTriggerChainName);
120  declareProperty("ValidationMode", m_validationMode);
121  declareProperty("xAODTruthLinkVector", m_truthLinkVecName="xAODTruthLinks");
122  declareProperty("Z0Gap", m_Z0GapCut = 5.0, "maximum gap between the z0 of both muons (in mm)");
123  declareProperty("TrackSelectionTool", m_selTool );
124  declareProperty("UseTrackSelectionTool", m_useTrackSelectionTool = false);
125  declareProperty("TrackToVertexIPEstimator", m_trackToVertexIPEstimator);
126 
127 
128  declareProperty("commonTreeFolder", m_commonTreeFolder, "/ZmumuValidationUserSel/common" );
129  declareProperty("defaultTreeFolder", m_defaultTreeFolder );
130  declareProperty("IDTreeFolder", m_IDTreeFolder );
131  declareProperty("refit1TreeFolder", m_refit1TreeFolder );
132  declareProperty("refit2TreeFolder", m_refit2TreeFolder );
133  declareProperty("truthTreeFolder", m_truthTreeFolder );
134  declareProperty("combTreeFolder", m_combTreeFolder );
135  declareProperty("MSTreeFolder", m_MSTreeFolder, "/ZmumuValidationUserSel/ms" );
136 
137  declareProperty("UnbiasVertex", m_doRemoval);
138 
139  declareProperty("commonTree", m_commonTreeName, "CommonTree" );
140  declareProperty("DefaultTree", m_defaultTreeName );
141  declareProperty("IDTree", m_IDTreeName );
142  declareProperty("CBTree", m_combTreeName );
143  declareProperty("Refit1Tree", m_refit1TreeName );
144  declareProperty("Refit2Tree", m_refit2TreeName );
145  declareProperty("MSTree", m_MSTreeName );
146 
147  declareProperty("doFourMuAnalysis", m_doFourMuAnalysis = false);
148  declareProperty("FourMuTreeFolder", m_FourMuTreeFolder);
149 
150  declareProperty("StoreZmumuNtuple", m_storeZmumuNtuple = true);
151  declareProperty("doZmumuEventDebug", m_doDebug);
152  declareProperty("MuonQuality", m_MuonQualityName = "Medium");
153  declareProperty("skipMS", m_skipMS = false);
154  declareProperty("useCustomMuonSelector", m_useCustomMuonSelector = false );
155  declareProperty("MuonSelector", m_muonSelector );
156 
157  declareProperty( "MinLumiBlock", m_minGoodLumiBlock = 0, "minimum lumiblock number to be accepted");
158  declareProperty( "MaxLumiBlock", m_maxGoodLumiBlock = 0, "maximum lumiblock number to be accepted");
159 
160  return;
161 }

◆ ~IDPerfMonZmumu()

IDPerfMonZmumu::~IDPerfMonZmumu ( )

Definition at line 165 of file IDPerfMonZmumu.cxx.

166 {}

Member Function Documentation

◆ bookTrees()

StatusCode IDPerfMonZmumu::bookTrees ( )
private

Definition at line 312 of file IDPerfMonZmumu.cxx.

313 {
314  m_h_cutflow = new TH1F("h_cutflow","cut flow histogram",11, -0.5, 9.5);
315 
316  ATH_MSG_DEBUG("initialize() ** bookTrees() ** m_commonTree name: " << m_commonTreeName.c_str());
317  ATH_MSG_DEBUG(" m_defaultTree name: " << m_defaultTreeName.c_str());
318  ATH_MSG_DEBUG(" m_IDTree name: " << m_IDTreeName.c_str());
319 
320  if (!m_commonTree) {
321  ATH_MSG_INFO("initialize() ** defining m_commonTree with name: " << m_commonTreeName.c_str());
322  m_commonTree = new TTree((m_commonTreeName).c_str(), m_ValidationTreeDescription.c_str());
323 
324  m_commonTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
325  m_commonTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
326  m_commonTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
327  m_commonTree->Branch("mu" , &m_event_mu, "mu/I");
328  m_commonTree->Branch("IDTrack_pt" , &m_IDTrack_pt);
329  m_commonTree->Branch("IDTrack_eta" , &m_IDTrack_eta);
330  m_commonTree->Branch("IDTrack_phi" , &m_IDTrack_phi);
331  m_commonTree->Branch("IDTrack_d0" , &m_IDTrack_d0);
332  m_commonTree->Branch("IDTrack_z0" , &m_IDTrack_z0);
333  m_commonTree->Branch("IDTrack_qoverp" , &m_IDTrack_qoverp);
334  m_commonTree->Branch("IDTrack_sigma_pt" , &m_IDTrack_sigma_pt);
335  m_commonTree->Branch("IDTrack_sigma_d0" , &m_IDTrack_sigma_d0);
336  m_commonTree->Branch("IDTrack_sigma_z0" , &m_IDTrack_sigma_z0);
337  m_commonTree->Branch("IDTrack_sigma_qoverp", &m_IDTrack_sigma_qoverp);
338  m_commonTree->Branch("CBTrack_pt" , &m_CBTrack_pt);
339  m_commonTree->Branch("CBTrack_eta" , &m_CBTrack_eta);
340  m_commonTree->Branch("CBTrack_phi" , &m_CBTrack_phi);
341  m_commonTree->Branch("CBTrack_d0" , &m_CBTrack_d0);
342  m_commonTree->Branch("CBTrack_z0" , &m_CBTrack_z0);
343  m_commonTree->Branch("CBTrack_qoverp" , &m_CBTrack_qoverp);
344  m_commonTree->Branch("CBTrack_sigma_pt" , &m_CBTrack_sigma_pt);
345  m_commonTree->Branch("CBTrack_sigma_d0" , &m_CBTrack_sigma_d0);
346  m_commonTree->Branch("CBTrack_sigma_z0" , &m_CBTrack_sigma_z0);
347  m_commonTree->Branch("CBTrack_sigma_qoverp", &m_CBTrack_sigma_qoverp);
348  m_commonTree->Branch("Refit1_pt" , &m_Refit1_pt);
349  m_commonTree->Branch("Refit1_eta" , &m_Refit1_eta);
350  m_commonTree->Branch("Refit1_phi" , &m_Refit1_phi);
351  m_commonTree->Branch("Refit1_d0" , &m_Refit1_d0);
352  m_commonTree->Branch("Refit1_z0" , &m_Refit1_z0);
353  m_commonTree->Branch("Refit1_qoverp" , &m_Refit1_qoverp);
354  m_commonTree->Branch("Refit1_sigma_pt" , &m_Refit1_sigma_pt);
355  m_commonTree->Branch("Refit1_sigma_d0" , &m_Refit1_sigma_d0);
356  m_commonTree->Branch("Refit1_sigma_z0" , &m_Refit1_sigma_z0);
357  m_commonTree->Branch("Refit1_sigma_qoverp" , &m_Refit1_sigma_qoverp);
358  m_commonTree->Branch("Refit2_pt" , &m_Refit2_pt);
359  m_commonTree->Branch("Refit2_eta" , &m_Refit2_eta);
360  m_commonTree->Branch("Refit2_phi" , &m_Refit2_phi);
361  m_commonTree->Branch("Refit2_d0" , &m_Refit2_d0);
362  m_commonTree->Branch("Refit2_z0" , &m_Refit2_z0);
363  m_commonTree->Branch("Refit2_qoverp" , &m_Refit2_qoverp);
364  m_commonTree->Branch("Refit2_sigma_pt" , &m_Refit2_sigma_pt);
365  m_commonTree->Branch("Refit2_sigma_d0" , &m_Refit2_sigma_d0);
366  m_commonTree->Branch("Refit2_sigma_z0" , &m_Refit2_sigma_z0);
367  m_commonTree->Branch("Refit2_sigma_qoverp" , &m_Refit2_sigma_qoverp);
368  m_commonTree->Branch("Truth_pt" , &m_Truth_pt);
369  m_commonTree->Branch("Truth_eta" , &m_Truth_eta);
370  m_commonTree->Branch("Truth_phi" , &m_Truth_phi);
371  m_commonTree->Branch("Truth_d0" , &m_Truth_d0);
372  m_commonTree->Branch("Truth_z0" , &m_Truth_z0);
373  m_commonTree->Branch("Truth_qoverp" , &m_Truth_qoverp);
374  m_commonTree->Branch("Truth_parent" , &m_Truth_parent);
375  m_commonTree->Branch("numberOfBLayerHits" , &m_nBLhits);
376  m_commonTree->Branch("numberOfPixelHits" , &m_nPIXhits);
377  m_commonTree->Branch("numberOfSCTHits" , &m_nSCThits);
378  m_commonTree->Branch("numberOfTRTHits" , &m_nTRThits);
379  }
380 
381  if ( !m_defaultTree){
382  ATH_MSG_INFO("initialize() ** defining m_defaultTree with name: " << m_defaultTreeName.c_str());
383  m_defaultTree = new TTree((m_defaultTreeName).c_str(), m_ValidationTreeDescription.c_str());
384 
385  m_defaultTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
386  m_defaultTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
387  m_defaultTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
388  m_defaultTree->Branch("mu" , &m_event_mu, "mu/I");
389 
390  m_defaultTree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
391  m_defaultTree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
392  m_defaultTree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
393  m_defaultTree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
394  m_defaultTree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
395  m_defaultTree->Branch("Negative_eta", &m_negative_eta, "Negative_Eta/D");
396  m_defaultTree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
397  m_defaultTree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
398  m_defaultTree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
399  m_defaultTree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
400  m_defaultTree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
401 
402  m_defaultTree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
403  m_defaultTree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
404  m_defaultTree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
405  m_defaultTree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
406  m_defaultTree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
407  m_defaultTree->Branch("Positive_eta", &m_positive_eta, "Positive_Eta/D");
408  m_defaultTree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
409  m_defaultTree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
410  m_defaultTree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
411  m_defaultTree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
412  m_defaultTree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
413 
414  if (m_doIP) {
415  m_defaultTree->Branch("Negative_d0_PV", &m_negative_d0_PV , "Negative_d0_PV/D");
416  m_defaultTree->Branch("Negative_z0_PV", &m_negative_z0_PV , "Negative_z0_PV/D");
417  m_defaultTree->Branch("Positive_z0_PV", &m_positive_z0_PV, "Positive_z0_PV/D");
418  m_defaultTree->Branch("Positive_d0_PV", &m_positive_d0_PV, "Positive_d0_PV/D");
419 
420  m_defaultTree->Branch("Negative_d0_PVerr", &m_negative_d0_PVerr, "Negative_d0_PVerr/D");
421  m_defaultTree->Branch("Negative_z0_PVerr", &m_negative_z0_PVerr, "Negative_z0_PVerr/D");
422  m_defaultTree->Branch("Positive_z0_PVerr", &m_positive_z0_PVerr, "Positive_z0_PVerr/D");
423  m_defaultTree->Branch("Positive_d0_PVerr", &m_positive_d0_PVerr, "Positive_d0_PVerr/D");
424 
425  m_defaultTree->Branch("pv_x", &m_pv_x , "pv_x/D");
426  m_defaultTree->Branch("pv_y", &m_pv_y , "pv_y/D");
427  m_defaultTree->Branch("pv_z", &m_pv_z , "pv_z/D");
428  m_defaultTree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
429  }
430  }
431 
432  bool isTreeNone = false;
433  if (m_IDTreeName.find("none") != std::string::npos) isTreeNone = true;
434  if ( !m_IDTree and !isTreeNone ){
435  ATH_MSG_INFO("initialize() ** defining IDPerfMonZmumu m_IDTree with name: " << m_IDTreeName.c_str());
436  m_IDTree = new TTree((m_IDTreeName).c_str(), m_ValidationTreeDescription.c_str());
437 
438  m_IDTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
439  m_IDTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
440  m_IDTree->Branch("lumi_bLock" , &m_lumi_block, "lumi_block/I");
441  m_IDTree->Branch("mu" , &m_event_mu, "mu/I");
442 
443  m_IDTree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
444  m_IDTree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
445  m_IDTree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
446  m_IDTree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
447  m_IDTree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
448  m_IDTree->Branch("Negative_Eta", &m_negative_eta, "Negative_Eta/D");
449  m_IDTree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
450  m_IDTree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
451  m_IDTree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
452  m_IDTree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
453  m_IDTree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
454 
455  m_IDTree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
456  m_IDTree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
457  m_IDTree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
458  m_IDTree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
459  m_IDTree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
460  m_IDTree->Branch("Positive_Eta", &m_positive_eta, "Positive_Eta/D");
461  m_IDTree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
462  m_IDTree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
463  m_IDTree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
464  m_IDTree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
465  m_IDTree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
466 
467  if(m_doIP){
468  m_IDTree->Branch("Negative_d0_PV", &m_negative_d0_PV , "Negative_d0_PV/D");
469  m_IDTree->Branch("Negative_z0_PV", &m_negative_z0_PV , "Negative_z0_PV/D");
470  m_IDTree->Branch("Positive_z0_PV", &m_positive_z0_PV, "Positive_z0_PV/D");
471  m_IDTree->Branch("Positive_d0_PV", &m_positive_d0_PV, "Positive_d0_PV/D");
472 
473  m_IDTree->Branch("Negative_d0_PVerr", &m_negative_d0_PVerr, "Negative_d0_PVerr/D");
474  m_IDTree->Branch("Negative_z0_PVerr", &m_negative_z0_PVerr, "Negative_z0_PVerr/D");
475  m_IDTree->Branch("Positive_z0_PVerr", &m_positive_z0_PVerr, "Positive_z0_PVerr/D");
476  m_IDTree->Branch("Positive_d0_PVerr", &m_positive_d0_PVerr, "Positive_d0_PVerr/D");
477 
478  m_IDTree->Branch("pv_x", &m_pv_x , "pv_x/D");
479  m_IDTree->Branch("pv_y", &m_pv_y , "pv_y/D");
480  m_IDTree->Branch("pv_z", &m_pv_z , "pv_z/D");
481  m_IDTree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
482  }
483  }
484 
485  // dealing with tree for Refit1 tracks
486  isTreeNone = false;
487  if (m_refit1TreeName.find("none") != std::string::npos) isTreeNone = true;
488  if ( m_doRefit && !m_refit1Tree && !isTreeNone ){
489  ATH_MSG_INFO("initialize() ** defining IDPerfMonZmumu m_refit1Tree with name: " << m_refit1TreeName.c_str());
490  m_refit1Tree = new TTree((m_refit1TreeName).c_str(), m_ValidationTreeDescription.c_str());
491 
492  m_refit1Tree->Branch("runNumber" , &m_runNumber, "runNumber/I");
493  m_refit1Tree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
494  m_refit1Tree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
495  m_refit1Tree->Branch("mu" , &m_event_mu, "mu/I");
496  m_refit1Tree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
497 
498  m_refit1Tree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
499  m_refit1Tree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
500  m_refit1Tree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
501  m_refit1Tree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
502  m_refit1Tree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
503  m_refit1Tree->Branch("Negative_Eta", &m_negative_eta, "Negative_Eta/D");
504  m_refit1Tree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
505  m_refit1Tree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
506  m_refit1Tree->Branch("Negative_z0_manualBS", &m_positive_z0_manualBS, "Negative_z0_manualBS/D");
507  m_refit1Tree->Branch("Negative_d0_manualBS", &m_positive_d0_manualBS, "Negative_d0_manualBS/D");
508  m_refit1Tree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
509  m_refit1Tree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
510  m_refit1Tree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
511 
512  m_refit1Tree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
513  m_refit1Tree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
514  m_refit1Tree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
515  m_refit1Tree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
516  m_refit1Tree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
517  m_refit1Tree->Branch("Positive_eta", &m_positive_eta, "Positive_Eta/D");
518  m_refit1Tree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
519  m_refit1Tree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
520  m_refit1Tree->Branch("Positive_z0_manualBS", &m_positive_z0_manualBS, "Positive_z0_manualBS/D");
521  m_refit1Tree->Branch("Positive_d0_manualBS", &m_positive_d0_manualBS, "Positive_d0_manualBS/D");
522  m_refit1Tree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
523  m_refit1Tree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
524  m_refit1Tree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
525 
526  if(m_doIP){
527  m_refit1Tree->Branch("Negative_d0_PV", &m_negative_d0_PV , "Negative_d0_PV/D");
528  m_refit1Tree->Branch("Negative_z0_PV", &m_negative_z0_PV , "Negative_z0_PV/D");
529  m_refit1Tree->Branch("Positive_z0_PV", &m_positive_z0_PV, "Positive_z0_PV/D");
530  m_refit1Tree->Branch("Positive_d0_PV", &m_positive_d0_PV, "Positive_d0_PV/D");
531 
532  m_refit1Tree->Branch("Negative_d0_PVerr", &m_negative_d0_PVerr , "Negative_d0_PVerr/D");
533  m_refit1Tree->Branch("Negative_z0_PVerr", &m_negative_z0_PVerr , "Negative_z0_PVerr/D");
534  m_refit1Tree->Branch("Positive_z0_PVerr", &m_positive_z0_PVerr, "Positive_z0_PVerr/D");
535  m_refit1Tree->Branch("Positive_d0_PVerr", &m_positive_d0_PVerr, "Positive_d0_PVerr/D");
536 
537  m_refit1Tree->Branch("pv_x", &m_pv_x , "pv_x/D");
538  m_refit1Tree->Branch("pv_y", &m_pv_y , "pv_y/D");
539  m_refit1Tree->Branch("pv_z", &m_pv_z , "pv_z/D");
540  m_refit1Tree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
541  }
542  }
543 
544  // dealing with tree for Refit2 tracks
545  isTreeNone = false;
546  if (m_refit2TreeName.find("none") != std::string::npos) isTreeNone = true;
547  if ( m_doRefit && !m_refit2Tree && !isTreeNone){
548  ATH_MSG_INFO("initialize() ** defining m_refit2Tree with name: " << m_refit2TreeName.c_str());
549  m_refit2Tree = new TTree((m_refit2TreeName).c_str(), m_ValidationTreeDescription.c_str());
550 
551  m_refit2Tree->Branch("runNumber" , &m_runNumber, "runNumber/I");
552  m_refit2Tree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
553  m_refit2Tree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
554  m_refit2Tree->Branch("mu" , &m_event_mu, "mu/I");
555  m_refit2Tree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
556 
557  m_refit2Tree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
558  m_refit2Tree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
559  m_refit2Tree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
560  m_refit2Tree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
561  m_refit2Tree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
562  m_refit2Tree->Branch("Negative_Eta", &m_negative_eta, "Negative_Eta/D");
563  m_refit2Tree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
564  m_refit2Tree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
565  m_refit2Tree->Branch("Negative_z0_manualBS", &m_positive_z0_manualBS, "Negative_z0_manualBS/D");
566  m_refit2Tree->Branch("Negative_d0_manualBS", &m_positive_d0_manualBS, "Negative_d0_manualBS/D");
567  m_refit2Tree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
568  m_refit2Tree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
569  m_refit2Tree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
570 
571  m_refit2Tree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
572  m_refit2Tree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
573  m_refit2Tree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
574  m_refit2Tree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
575  m_refit2Tree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
576  m_refit2Tree->Branch("Positive_Eta", &m_positive_eta, "Positive_Eta/D");
577  m_refit2Tree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
578  m_refit2Tree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
579  m_refit2Tree->Branch("Positive_z0_manualBS", &m_positive_z0_manualBS, "Positive_z0_manualBS/D");
580  m_refit2Tree->Branch("Positive_d0_manualBS", &m_positive_d0_manualBS, "Positive_d0_manualBS/D");
581  m_refit2Tree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
582  m_refit2Tree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
583  m_refit2Tree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
584 
585 
586  if(m_doIP){
587  m_refit2Tree->Branch("Negative_d0_PV", &m_negative_d0_PV , "Negative_d0_PV/D");
588  m_refit2Tree->Branch("Negative_z0_PV", &m_negative_z0_PV , "Negative_z0_PV/D");
589  m_refit2Tree->Branch("Positive_d0_PV", &m_positive_d0_PV , "Positive_d0_PV/D");
590  m_refit2Tree->Branch("Positive_z0_PV", &m_positive_z0_PV , "Positive_z0_PV/D");
591 
592 
593  m_refit2Tree->Branch("Negative_z0_PVerr", &m_negative_z0_PVerr, "Negative_z0_PVerr/D");
594  m_refit2Tree->Branch("Negative_d0_PVerr", &m_negative_d0_PVerr, "Negative_d0_PVerr/D");
595  m_refit2Tree->Branch("Positive_z0_PVerr", &m_positive_z0_PVerr, "Positive_z0_PVerr/D");
596  m_refit2Tree->Branch("Positive_d0_PVerr", &m_positive_d0_PVerr, "Positive_d0_PVerr/D");
597 
598  m_refit2Tree->Branch("pv_x", &m_pv_x , "pv_x/D");
599  m_refit2Tree->Branch("pv_y", &m_pv_y , "pv_y/D");
600  m_refit2Tree->Branch("pv_z", &m_pv_z , "pv_z/D");
601 
602  m_refit2Tree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
603  }
604  }
605 
606  isTreeNone = false;
607  if (m_combTreeName.find("none") != std::string::npos) isTreeNone = true;
608  if( !m_combTree && !m_skipMS && !isTreeNone){
609  ATH_MSG_INFO("initialize() ** defining IDPerfMonZmumu m_combTree with name: " << m_combTreeName.c_str());
610  m_combTree = new TTree((m_combTreeName).c_str(), m_ValidationTreeDescription.c_str());
611 
612  m_combTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
613  m_combTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
614  m_combTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
615  m_combTree->Branch("mu" , &m_event_mu, "mu/I");
616  m_combTree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
617 
618  m_combTree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
619  m_combTree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
620  m_combTree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
621  m_combTree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
622  m_combTree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
623  m_combTree->Branch("Negative_eta", &m_negative_eta, "Negative_eta/D");
624  m_combTree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
625  m_combTree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
626  m_combTree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
627  m_combTree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
628  m_combTree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
629 
630  m_combTree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
631  m_combTree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
632  m_combTree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
633  m_combTree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
634  m_combTree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
635  m_combTree->Branch("Positive_eta", &m_positive_eta, "Positive_Eta/D");
636  m_combTree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
637  m_combTree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
638  m_combTree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
639  m_combTree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
640  m_combTree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
641 
642  if(m_doIP){
643  m_combTree->Branch("Negative_z0_PV", &m_negative_z0_PV, "Negative_z0_PV/D");
644  m_combTree->Branch("Negative_d0_PV", &m_negative_d0_PV, "Negative_d0_PV/D");
645  m_combTree->Branch("Positive_z0_PV", &m_positive_z0_PV, "Positive_z0_PV/D");
646  m_combTree->Branch("Positive_d0_PV", &m_positive_d0_PV, "Positive_d0_PV/D");
647 
648  m_combTree->Branch("Negative_z0_PVerr", &m_negative_z0_PVerr, "Negative_z0_PVerr/D");
649  m_combTree->Branch("Negative_d0_PVerr", &m_negative_d0_PVerr, "Negative_d0_PVerr/D");
650  m_combTree->Branch("Positive_z0_PVerr", &m_positive_z0_PVerr, "Positive_z0_PVerr/D");
651  m_combTree->Branch("Positive_d0_PVerr", &m_positive_d0_PVerr, "Positive_d0_PVerr/D");
652 
653  m_combTree->Branch("pv_x", &m_pv_x , "pv_x/D");
654  m_combTree->Branch("pv_y", &m_pv_y , "pv_y/D");
655  m_combTree->Branch("pv_z", &m_pv_z , "pv_z/D");
656 
657  m_combTree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
658  }
659  }
660 
661 
662  isTreeNone = false;
663  if (m_MSTreeName.find("none") != std::string::npos) isTreeNone = true;
664  if( !m_MSTree && !m_skipMS && !isTreeNone){
665  ATH_MSG_INFO("initialize() ** defining IDPerfMon MSTree ");
666 
667  m_MSTree = new TTree(m_MSTreeName.c_str(), m_ValidationTreeDescription.c_str());
668 
669  m_MSTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
670  m_MSTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
671  m_MSTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
672  m_MSTree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
673 
674  m_MSTree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
675  m_MSTree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
676  m_MSTree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
677  m_MSTree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
678  m_MSTree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
679  m_MSTree->Branch("Negative_Eta", &m_negative_eta, "Negative_Eta/D");
680  m_MSTree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
681  m_MSTree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
682  m_MSTree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
683  m_MSTree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
684  m_MSTree->Branch("Negative_sigma_pt", &m_negative_sigma_pt, "Negative_sigma_pt/D");
685 
686  m_MSTree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
687  m_MSTree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
688  m_MSTree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
689  m_MSTree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
690  m_MSTree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
691  m_MSTree->Branch("Positive_Eta", &m_positive_eta, "Positive_Eta/D");
692  m_MSTree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
693  m_MSTree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
694  m_MSTree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
695  m_MSTree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
696  m_MSTree->Branch("Positive_sigma_pt", &m_positive_sigma_pt, "Positive_sigma_pt/D");
697  }
698 
699  if( m_isMC && !m_truthTree ){
700  m_truthTree = new TTree(m_truthTreeName.c_str(), m_ValidationTreeDescription.c_str());
701 
702  m_truthTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
703  m_truthTree->Branch("eventNumber" , &m_evtNumber, "eventNumber/I");
704  m_truthTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
705  m_truthTree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
706 
707  m_truthTree->Branch("Negative_Px", &m_negative_px, "Negative_Px/D");
708  m_truthTree->Branch("Negative_Py", &m_negative_py, "Negative_Py/D");
709  m_truthTree->Branch("Negative_Pt", &m_negative_pt, "Negative_Pt/D");
710  m_truthTree->Branch("Negative_Pz", &m_negative_pz, "Negative_Pz/D");
711  m_truthTree->Branch("Negative_Phi", &m_negative_phi, "Negative_Phi/D");
712  m_truthTree->Branch("Negative_Eta", &m_negative_eta, "Negative_Eta/D");
713  m_truthTree->Branch("Negative_z0", &m_negative_z0, "Negative_z0/D");
714  m_truthTree->Branch("Negative_d0", &m_negative_d0, "Negative_d0/D");
715  m_truthTree->Branch("Negative_z0_err", &m_negative_z0_err, "Negative_z0_err/D");
716  m_truthTree->Branch("Negative_d0_err", &m_negative_d0_err, "Negative_d0_err/D");
717  m_truthTree->Branch("Negative_parent", &m_negative_parent, "Negative_parent/I");
718 
719  m_truthTree->Branch("Positive_Px", &m_positive_px, "Positive_Px/D");
720  m_truthTree->Branch("Positive_Py", &m_positive_py, "Positive_Py/D");
721  m_truthTree->Branch("Positive_Pt", &m_positive_pt, "Positive_Pt/D");
722  m_truthTree->Branch("Positive_Pz", &m_positive_pz, "Positive_Pz/D");
723  m_truthTree->Branch("Positive_Phi", &m_positive_phi, "Positive_Phi/D");
724  m_truthTree->Branch("Positive_Eta", &m_positive_eta, "Positive_Eta/D");
725  m_truthTree->Branch("Positive_z0", &m_positive_z0, "Positive_z0/D");
726  m_truthTree->Branch("Positive_d0", &m_positive_d0, "Positive_d0/D");
727  m_truthTree->Branch("Positive_z0_err", &m_positive_z0_err, "Positive_z0_err/D");
728  m_truthTree->Branch("Positive_d0_err", &m_positive_d0_err, "Positive_d0_err/D");
729  m_truthTree->Branch("Positive_parent", &m_positive_parent, "Positive_parent/I");
730  }
731 
732  if (m_doFourMuAnalysis && !m_FourMuTree) {
733  ATH_MSG_INFO("initialize() ** defining m_FourMuTree ");
734  m_FourMuTree = new TTree((m_FourMuTreeName).c_str(), "Four Muon monitoring");
735 
736  m_FourMuTree->Branch("runNumber" , &m_runNumber, "runNumber/I");
737  m_FourMuTree->Branch("eventNumber", &m_evtNumber, "eventNumber/I");
738  m_FourMuTree->Branch("lumi_block" , &m_lumi_block, "lumi_block/I");
739  m_FourMuTree->Branch("mu" , &m_event_mu, "mu/I");
740  m_FourMuTree->Branch("preScale" , &m_triggerPrescale, "preScale/I");
741  m_FourMuTree->Branch("nVertex" , &m_nVertex, "nVertex/I");
742 
743  m_FourMuTree->Branch("Negative_1_Px", &m_negative_px, "Negative_1_Px/D");
744  m_FourMuTree->Branch("Negative_1_Py", &m_negative_py, "Negative_1_Py/D");
745  m_FourMuTree->Branch("Negative_1_Pz", &m_negative_pz, "Negative_1_Pz/D");
746  m_FourMuTree->Branch("Negative_1_z0", &m_negative_z0, "Negative_1_z0/D");
747  m_FourMuTree->Branch("Negative_1_d0", &m_negative_d0, "Negative_1_d0/D");
748  m_FourMuTree->Branch("Negative_1_z0_err", &m_negative_z0_err, "Negative_1_z0_err/D");
749  m_FourMuTree->Branch("Negative_1_d0_err", &m_negative_d0_err, "Negative_1_d0_err/D");
750  m_FourMuTree->Branch("Negative_1_vtx", &m_negative_1_vtx, "Negative_1_vtx/I"); // vertex identifier
751 
752  m_FourMuTree->Branch("Negative_2_Px", &m_negative_2_px, "Negative_2_Px/D");
753  m_FourMuTree->Branch("Negative_2_Py", &m_negative_2_py, "Negative_2_Py/D");
754  m_FourMuTree->Branch("Negative_2_Pz", &m_negative_2_pz, "Negative_2_Pz/D");
755  m_FourMuTree->Branch("Negative_2_z0", &m_negative_2_z0, "Negative_2_z0/D");
756  m_FourMuTree->Branch("Negative_2_d0", &m_negative_2_d0, "Negative_2_d0/D");
757  m_FourMuTree->Branch("Negative_2_z0_err", &m_negative_2_z0_err, "Negative_2_z0_err/D");
758  m_FourMuTree->Branch("Negative_2_d0_err", &m_negative_2_d0_err, "Negative_2_d0_err/D");
759  m_FourMuTree->Branch("Negative_2_vtx", &m_negative_2_vtx, "Negative_2_vtx/I");
760 
761  m_FourMuTree->Branch("Positive_1_Px", &m_positive_px, "Positive_1_Px/D");
762  m_FourMuTree->Branch("Positive_1_Py", &m_positive_py, "Positive_1_Py/D");
763  m_FourMuTree->Branch("Positive_1_Pz", &m_positive_pz, "Positive_1_Pz/D");
764  m_FourMuTree->Branch("Positive_1_z0", &m_positive_z0, "Positive_1_z0/D");
765  m_FourMuTree->Branch("Positive_1_d0", &m_positive_d0, "Positive_1_d0/D");
766  m_FourMuTree->Branch("Positive_1_z0_err", &m_positive_z0_err, "Positive_1_z0_err/D");
767  m_FourMuTree->Branch("Positive_1_d0_err", &m_positive_d0_err, "Positive_1_d0_err/D");
768  m_FourMuTree->Branch("Positive_1_vtx", &m_positive_1_vtx, "Positive_1_vtx/I");
769 
770  m_FourMuTree->Branch("Positive_2_Px", &m_positive_2_px, "Positive_1_Px/D");
771  m_FourMuTree->Branch("Positive_2_Py", &m_positive_2_py, "Positive_1_Py/D");
772  m_FourMuTree->Branch("Positive_2_Pz", &m_positive_2_pz, "Positive_1_Pz/D");
773  m_FourMuTree->Branch("Positive_2_z0", &m_positive_2_z0, "Positive_1_z0/D");
774  m_FourMuTree->Branch("Positive_2_d0", &m_positive_2_d0, "Positive_1_d0/D");
775  m_FourMuTree->Branch("Positive_2_z0_err", &m_positive_2_z0_err,"Positive_1_z0_err/D");
776  m_FourMuTree->Branch("Positive_2_d0_err", &m_positive_2_d0_err,"Positive_1_d0_err/D");
777  m_FourMuTree->Branch("Positive_2_vtx", &m_positive_2_vtx, "Positive_2_vtx/I");
778 
779  // electrons
780  m_FourMuTree->Branch("ElNegative_1_Px", &m_el_negative1_px, "ElNegative_1_Px/D");
781  m_FourMuTree->Branch("ElNegative_1_Py", &m_el_negative1_py, "ElNegative_1_Py/D");
782  m_FourMuTree->Branch("ElNegative_1_Pz", &m_el_negative1_pz, "ElNegative_1_Pz/D");
783  m_FourMuTree->Branch("ElNegative_1_z0", &m_el_negative1_z0, "ElNegative_1_z0/D");
784  m_FourMuTree->Branch("ElNegative_1_d0", &m_el_negative1_d0, "ElNegative_1_d0/D");
785  m_FourMuTree->Branch("ElNegative_1_z0_err", &m_el_negative1_z0_err, "ElNegative_1_z0_err/D");
786  m_FourMuTree->Branch("ElNegative_1_d0_err", &m_el_negative1_d0_err, "ElNegative_1_d0_err/D");
787  m_FourMuTree->Branch("ElNegative_1_vtx", &m_el_negative1_vtx, "ElNegative_1_vtx/I"); // vertex identifier
788 
789  m_FourMuTree->Branch("ElNegative_2_Px", &m_el_negative2_px, "ElNegative_2_Px/D");
790  m_FourMuTree->Branch("ElNegative_2_Py", &m_el_negative2_py, "ElNegative_2_Py/D");
791  m_FourMuTree->Branch("ElNegative_2_Pz", &m_el_negative2_pz, "ElNegative_2_Pz/D");
792  m_FourMuTree->Branch("ElNegative_2_z0", &m_el_negative2_z0, "ElNegative_2_z0/D");
793  m_FourMuTree->Branch("ElNegative_2_d0", &m_el_negative2_d0, "ElNegative_2_d0/D");
794  m_FourMuTree->Branch("ElNegative_2_z0_err", &m_el_negative2_z0_err, "ElNegative_2_z0_err/D");
795  m_FourMuTree->Branch("ElNegative_2_d0_err", &m_el_negative2_d0_err, "ElNegative_2_d0_err/D");
796  m_FourMuTree->Branch("ElNegative_2_vtx", &m_el_negative2_vtx, "ElNegative_2_vtx/I"); // vertex identifier
797 
798  m_FourMuTree->Branch("ElPositive_1_Px", &m_el_positive1_px, "ElPositive_1_Px/D");
799  m_FourMuTree->Branch("ElPositive_1_Py", &m_el_positive1_py, "ElPositive_1_Py/D");
800  m_FourMuTree->Branch("ElPositive_1_Pz", &m_el_positive1_pz, "ElPositive_1_Pz/D");
801  m_FourMuTree->Branch("ElPositive_1_z0", &m_el_positive1_z0, "ElPositive_1_z0/D");
802  m_FourMuTree->Branch("ElPositive_1_d0", &m_el_positive1_d0, "ElPositive_1_d0/D");
803  m_FourMuTree->Branch("ElPositive_1_z0_err", &m_el_positive1_z0_err, "ElPositive_1_z0_err/D");
804  m_FourMuTree->Branch("ElPositive_1_d0_err", &m_el_positive1_d0_err, "ElPositive_1_d0_err/D");
805  m_FourMuTree->Branch("ElPositive_1_vtx", &m_el_positive1_vtx, "ElPositive_1_vtx/I"); // vertex identifier
806 
807  m_FourMuTree->Branch("ElPositive_2_Px", &m_el_positive2_px, "ElPositive_2_Px/D");
808  m_FourMuTree->Branch("ElPositive_2_Py", &m_el_positive2_py, "ElPositive_2_Py/D");
809  m_FourMuTree->Branch("ElPositive_2_Pz", &m_el_positive2_pz, "ElPositive_2_Pz/D");
810  m_FourMuTree->Branch("ElPositive_2_z0", &m_el_positive2_z0, "ElPositive_2_z0/D");
811  m_FourMuTree->Branch("ElPositive_2_d0", &m_el_positive2_d0, "ElPositive_2_d0/D");
812  m_FourMuTree->Branch("ElPositive_2_z0_err", &m_el_positive2_z0_err, "ElPositive_2_z0_err/D");
813  m_FourMuTree->Branch("ElPositive_2_d0_err", &m_el_positive2_d0_err, "ElPositive_2_d0_err/D");
814  m_FourMuTree->Branch("ElPositive_2_vtx", &m_el_positive2_vtx, "ElPositive_2_vtx/I"); // vertex identifier
815 
816  // other quantities
817  m_FourMuTree->Branch("minv4mu", &m_4mu_minv, "minv4mu/D");
818  m_FourMuTree->Branch("pv_x", &m_pv_x , "pv_x/D");
819  m_FourMuTree->Branch("pv_y", &m_pv_y , "pv_y/D");
820  m_FourMuTree->Branch("pv_z", &m_pv_z , "pv_z/D");
821  m_FourMuTree->Branch("nTrkInVtx", &m_nTrkInVtx, "nTrkInVtx/I");
822 
823  m_FourMuTree->Branch("met", &m_met, "met/D");
824  m_FourMuTree->Branch("metphi", &m_metphi, "metphi/D");
825  }
826 
827  // now register the Trees
828  ATH_MSG_INFO("initialize() Going to register the mu+mu- trees");
829  ITHistSvc* tHistSvc = nullptr;
830  if (service("THistSvc",tHistSvc).isFailure()){
831  ATH_MSG_ERROR("initialize() Could not find Hist Service -> Switching ValidationMode Off !");
832  m_validationMode = false;
833  }
834 
835  if (m_commonTree) {
836  if ((tHistSvc->regTree(m_commonTreeFolder, m_commonTree)).isSuccess() ) {
837  ATH_MSG_INFO("initialize() commonTree succesfully registered!");
838  }
839  else {
840  ATH_MSG_ERROR("initialize() Could not register the validation commonTree -> Switching ValidationMode Off !");
841  delete m_commonTree; m_commonTree = nullptr;
842  m_validationMode = false;
843  }
844  }
845 
846  if (m_IDTree) {
847  if ((tHistSvc->regTree(m_IDTreeFolder, m_IDTree)).isSuccess() ) {
848  ATH_MSG_INFO("initialize() IDTree succesfully registered!");
849  }
850  else {
851  ATH_MSG_ERROR("initialize() Could not register the validation IDTree -> Switching ValidationMode Off !");
852  delete m_IDTree; m_IDTree = nullptr;
853  m_validationMode = false;
854  }
855  }
856 
857  if ( m_skipMS ) {
858  ATH_MSG_INFO("CBtree has to be skipped: flag ON");
859  delete m_combTree; m_combTree = nullptr;
860  }
861  else {
862  if (m_combTree) {
863  if ((tHistSvc->regTree(m_combTreeFolder, m_combTree)).isSuccess() ) {
864  ATH_MSG_INFO("initialize() CBTree succesfully registered!");
865  }
866  else {
867  ATH_MSG_ERROR("initialize() Could not register the validation CBTree -> Switching ValidationMode Off !");
868  delete m_combTree; m_combTree = nullptr;
869  m_validationMode = false;
870  }
871  }
872  }
873 
874  if ( m_skipMS ) {
875  ATH_MSG_INFO("MStree has to be skipped: flag ON");
876  delete m_MSTree; m_MSTree = nullptr;
877  }
878  else {
879  if (m_MSTree) {
880  if ( (tHistSvc->regTree(m_MSTreeFolder, m_MSTree)).isSuccess() ){
881  ATH_MSG_INFO("initialize() MSTree succesfully registered!");
882  }
883  else {
884  ATH_MSG_ERROR("initialize() Could not register the validation MSTree -> Switching ValidationMode Off !");
885  delete m_MSTree; m_MSTree = nullptr;
886  m_validationMode = false;
887  }
888  }
889  }
890 
891  if( m_doRefit ){
892  if (m_refit1Tree) {
893  if ((tHistSvc->regTree(m_refit1TreeFolder, m_refit1Tree)).isSuccess() ) {
894  ATH_MSG_INFO("initialize() Refit1 Tree succesfully registered!");
895  }
896  else{
897  ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !");
898  delete m_refit1Tree; m_refit1Tree = nullptr;
899  m_validationMode = false;
900  }
901  }
902 
903  if (m_refit2Tree) {
904  if ((tHistSvc->regTree(m_refit2TreeFolder, m_refit2Tree)).isSuccess() ) {
905  ATH_MSG_INFO("initialize() Refit2 Tree succesfully registered!");
906  }
907  else {
908  ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !");
909  delete m_refit2Tree; m_refit2Tree = nullptr;
910  m_validationMode = false;
911  }
912  }
913  }
914 
915  if (m_isMC) {
916  if ((tHistSvc->regTree(m_truthTreeFolder, m_truthTree)).isSuccess() ) {
917  ATH_MSG_INFO("initialize() truthTree Tree succesfully registered!");
918  }
919  else {
920  ATH_MSG_ERROR("initialize() Could not register the validation truth Tree -> Switching ValidationMode Off !");
921  delete m_truthTree; m_truthTree = nullptr;
922  m_validationMode = false;
923  }
924  }
925 
926  if (m_doFourMuAnalysis) {
927  if ((tHistSvc->regTree(m_FourMuTreeFolder, m_FourMuTree)).isSuccess() ) {
928  ATH_MSG_INFO("initialize() FourMu Tree succesfully registered!");
929  }
930  else {
931  ATH_MSG_ERROR("initialize() Could not register the validation FourMu Tree -> Switching ValidationMode Off !");
932  delete m_FourMuTree; m_FourMuTree = nullptr;
933  m_validationMode = false;
934  }
935  }
936 
937  return StatusCode::SUCCESS;
938 }

◆ CheckTriggerStatusAndPrescale()

StatusCode IDPerfMonZmumu::CheckTriggerStatusAndPrescale ( )
private

Definition at line 2292 of file IDPerfMonZmumu.cxx.

2293 {
2294  m_triggerPrescale = 1; // default value
2295 
2296  // check trigger status
2297  if(m_triggerDecision.retrieve().isFailure()) {
2298  ATH_MSG_FATAL("Unable to retrieve " << m_triggerDecision << " turn it off");
2299  return StatusCode::FAILURE;
2300  }
2301  else {
2302  ATH_MSG_DEBUG("retrieved tool: " << m_triggerDecision );
2303  }
2304 
2305  float thisEventTriggerPrescale = 999999.9;
2306  float thisHLTTriggerPrescale = 999999.9;
2307  bool thisHLTIsPassed = false;
2308  std::string thisHLTTriggerName;
2309  std::string thisEventTriggerName;
2310 
2311  // HLT triggers
2312  const std::vector<std::string> myHLTtriglist = m_triggerDecision->getChainGroup("HLT_mu.*, HLT_2mu.*")->getListOfTriggers();
2313  for (int i=0; i < (int) myHLTtriglist.size(); i++) {
2314  if ( m_triggerDecision->isPassed(myHLTtriglist.at(i)) ) {
2315  ATH_MSG_DEBUG("HLT trigger = " << i << " out of " << myHLTtriglist.size() << " --> " << myHLTtriglist.at(i) << " isPassed? " << m_triggerDecision->isPassed(myHLTtriglist.at(i)) << " prescale: " << m_triggerDecision->getChainGroup(myHLTtriglist.at(i))->getPrescale() );
2316  }
2317  if ( m_triggerDecision->isPassed(myHLTtriglist.at(i)) ) { // trigger is passed
2318  thisHLTIsPassed = true;
2319  float thisprescale = m_triggerDecision->getChainGroup(myHLTtriglist.at(i))->getPrescale();
2320  if (thisprescale < thisHLTTriggerPrescale) {
2321  thisHLTTriggerPrescale = thisprescale;
2322  thisHLTTriggerName = myHLTtriglist.at(i);
2323  }
2324  }
2325  }
2326  if (thisHLTTriggerPrescale < 1) thisHLTTriggerPrescale = 1;
2327  ATH_MSG_DEBUG("Event HLT trigger prescale = " << thisHLTTriggerPrescale);
2328 
2329  //if (thisL1IsPassed && thisHLTIsPassed) {
2330  if (thisHLTIsPassed) {
2331  ATH_MSG_DEBUG("Trigger passed -> accept event");
2332  }
2333  else{
2334  ATH_MSG_DEBUG("Trigger Failed -> reject event");
2335  return StatusCode::FAILURE;
2336  }
2337 
2338  // event prescale
2339  thisEventTriggerPrescale = thisHLTTriggerPrescale;
2340  thisEventTriggerName = thisHLTTriggerName;
2341  ATH_MSG_DEBUG("Event trigger prescale = " << thisEventTriggerPrescale);
2342  ATH_MSG_DEBUG("Event trigger name = " << thisEventTriggerName);
2343 
2344  m_triggerPrescale = thisEventTriggerPrescale;
2345  m_triggerName = thisEventTriggerName;
2346 
2347  return StatusCode::SUCCESS;
2348 }

◆ Clear4MuNtupleVariables()

void IDPerfMonZmumu::Clear4MuNtupleVariables ( )
private

Definition at line 2441 of file IDPerfMonZmumu.cxx.

2442 {
2443  m_positive_px = 0.;
2444  m_positive_py = 0.;
2445  m_positive_pz = 0.;
2446  m_positive_d0 = 0.;
2447  m_positive_z0 = 0.;
2448  m_positive_d0_manualBS = 0.;
2449  m_positive_z0_manualBS = 0.;
2450  m_positive_d0_err = 0.;
2451  m_positive_z0_err = 0.;
2452  m_positive_sigma_pt = 0.;
2453  m_positive_1_vtx = 0;
2454  m_positive_parent = 0;
2455 
2456  m_negative_px = 0.;
2457  m_negative_py = 0.;
2458  m_negative_pz = 0.;
2459  m_negative_d0 = 0.;
2460  m_negative_z0 = 0.;
2461  m_negative_d0_manualBS = 0.;
2462  m_negative_z0_manualBS = 0.;
2463  m_negative_d0_err = 0.;
2464  m_negative_z0_err = 0.;
2465  m_negative_sigma_pt = 0.;
2466  m_negative_1_vtx = 0;
2467  m_negative_parent = 0;
2468 
2469  m_positive_2_px = 0.;
2470  m_positive_2_py = 0.;
2471  m_positive_2_pz = 0.;
2472  m_positive_2_d0 = 0.;
2473  m_positive_2_z0 = 0.;
2474  m_positive_2_d0_err = 0.;
2475  m_positive_2_z0_err = 0.;
2476  m_positive_2_vtx = 0;
2477 
2478  m_negative_2_px = 0.;
2479  m_negative_2_py = 0.;
2480  m_negative_2_pz = 0.;
2481  m_negative_2_d0 = 0.;
2482  m_negative_2_z0 = 0.;
2483  m_negative_2_d0_err = 0.;
2484  m_negative_2_z0_err = 0.;
2485  m_negative_2_vtx = 0;
2486 
2487  // electrons
2488  m_el_negative1_px = 0.;
2489  m_el_negative1_py = 0.;
2490  m_el_negative1_pz = 0.;
2491  m_el_negative1_d0 = 0.;
2492  m_el_negative1_z0 = 0.;
2493  m_el_negative1_d0_err = 0.;
2494  m_el_negative1_z0_err = 0.;
2495  m_el_negative1_vtx = 0;
2496 
2497  m_el_negative2_px = 0.;
2498  m_el_negative2_py = 0.;
2499  m_el_negative2_pz = 0.;
2500  m_el_negative2_d0 = 0.;
2501  m_el_negative2_z0 = 0.;
2502  m_el_negative2_d0_err = 0.;
2503  m_el_negative2_z0_err = 0.;
2504  m_el_negative2_vtx = 0;
2505 
2506  m_el_positive1_px = 0.;
2507  m_el_positive1_py = 0.;
2508  m_el_positive1_pz = 0.;
2509  m_el_positive1_d0 = 0.;
2510  m_el_positive1_z0 = 0.;
2511  m_el_positive1_d0_err = 0.;
2512  m_el_positive1_z0_err = 0.;
2513  m_el_positive1_vtx = 0;
2514 
2515  m_el_positive2_px = 0.;
2516  m_el_positive2_py = 0.;
2517  m_el_positive2_pz = 0.;
2518  m_el_positive2_d0 = 0.;
2519  m_el_positive2_z0 = 0.;
2520  m_el_positive2_d0_err = 0.;
2521  m_el_positive2_z0_err = 0.;
2522  m_el_positive2_vtx = 0;
2523 
2524  // other quantities
2525  m_nVertex = 0;
2526  m_pv_x = 0; m_pv_y = 0; m_pv_z = 0;
2527  m_4mu_minv = 0.;
2528 
2529  return;
2530 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode IDPerfMonZmumu::execute ( )
virtual

– START 4 lepton analysis

– END 4 lepton analysis

Definition at line 949 of file IDPerfMonZmumu.cxx.

950 {
951  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** START **");
952 
953  SG::ReadHandle<xAOD::EventInfo> eventInfo (m_EventInfoKey, getContext());
954  if(eventInfo.isValid()) {
955  m_runNumber = eventInfo->runNumber();
956  m_evtNumber = eventInfo->eventNumber();
957  m_lumi_block = eventInfo->lumiBlock();
958  m_event_mu = eventInfo->actualInteractionsPerCrossing();
959  ATH_MSG_DEBUG(" Execute() starting on --> Run: " << m_runNumber << " event: " << m_evtNumber << " Lumiblock: " << m_lumi_block);
960  }
961  else {
962  ATH_MSG_DEBUG(" IDPerfMonZmumu::execute evtStore->retrieve (eventInfo) failed .. trying another strategy.. ");
963  SG::ReadHandle<xAOD::EventInfo> eventInfo2(m_EventInfoKey);
964  if (eventInfo2.isValid()) {
965  m_runNumber = eventInfo2->runNumber();
966  m_evtNumber = eventInfo2->eventNumber();
967  m_lumi_block = eventInfo2->lumiBlock();
968  m_event_mu = eventInfo2->actualInteractionsPerCrossing();
969  ATH_MSG_DEBUG(" Execute() starting on --> Run: " << m_runNumber << " event: " << m_evtNumber << " Lumiblock: " << m_lumi_block);
970  }
971 
972  else{
973  ATH_MSG_ERROR("** IDPerfMonZmumu::execute ** Could not retrieve event info.");
974  }
975  }
976 
978  if (m_doFourMuAnalysis) {
979  ATH_MSG_DEBUG(" ** IDPerfMonZmumu::execute ** calling FourLeptonAnalysis()...");
980  StatusCode fourLeptAnaStatus = this->RunFourLeptonAnalysis();
981  if (fourLeptAnaStatus.isSuccess()) ATH_MSG_INFO (" ** IDPerfMonZmumu::execute ** RunFourLeptonAnalysis() SUCCESS -> found a new event");
982  }
984 
985 
986  // check if the muon-pair passed the resonance selection cuts:
987  ATH_MSG_DEBUG(" ** IDPerfMonZmumu::execute ** calling dimuon analysis m_xZmm.Reco()...");
988  if( m_xZmm.Reco( m_lumi_block ) ){
989  ATH_MSG_INFO( " Run: " << m_runNumber
990  << " event: " << m_evtNumber
991  << " Lumiblock: " << m_lumi_block
992  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ** SUCCESS **");
993  }
994  else {
995  ATH_MSG_DEBUG( " Run: " << m_runNumber
996  << " event: " << m_evtNumber
997  << " Lumiblock: " << m_lumi_block
998  << " Failed dimuon reconstruction. m_xZmm.Reco() returned FALSE ");
999  return StatusCode::SUCCESS;
1000  }
1001 
1002  //
1003  // If this point is reached -> there is a good mu+mu- pair that stisfies all selection cuts
1004  //
1005 
1006  if (m_UseTrigger) {
1007  StatusCode isTriggerPassed = CheckTriggerStatusAndPrescale ();
1008  if (isTriggerPassed == StatusCode::SUCCESS) {
1009  ATH_MSG_DEBUG("Trigger passed -> accept event");
1010  }
1011  else{
1012  ATH_MSG_DEBUG("Trigger Failed -> reject event --> leave event");
1013  return StatusCode::SUCCESS;
1014  }
1015  }
1016 
1017  // std::cout << " ** IDPerfMonZmumu ** extracting muon_pos and muon_neg... " << std::endl;
1018  const xAOD::Muon* muon_pos = m_xZmm.getCombMuon(m_xZmm.getPosMuon(ZmumuEvent::CB));
1019  const xAOD::Muon* muon_neg = m_xZmm.getCombMuon(m_xZmm.getNegMuon(ZmumuEvent::CB));
1020 
1021  const xAOD::TrackParticle* ppos_comb = nullptr; const xAOD::Vertex* ppos_comb_v = nullptr;
1022  const xAOD::TrackParticle* pneg_comb = nullptr; const xAOD::Vertex* pneg_comb_v = nullptr;
1023 
1024  //To protect against failures of the estimation
1025  StatusCode success_pos = StatusCode::FAILURE;
1026  StatusCode success_neg = StatusCode::FAILURE;
1027 
1028  if (muon_pos && muon_neg) { // if both combined muons exist and were sucessfully retrieved
1029  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** combined muons exist ** retrieving their m_trackparticleName: " << m_trackParticleName.c_str());
1030 
1031  if (m_trackParticleName.find("InnerDetectorTrackParticles") != std::string::npos) {
1032  ATH_MSG_INFO("** IDPerfMonZmumu::execute ** Retrieving InnerDetectorTrackParticles of the accepted muons");
1033  ppos_comb = muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
1034  pneg_comb = muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
1035 
1036  if (!ppos_comb || !pneg_comb) {
1037  ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** InnerDetectorTrackParticles are requested but they are not present. Exiting event.");
1038  return StatusCode::SUCCESS;
1039  }
1040  } // InnerDetectorTrackParticles
1041  if (m_trackParticleName.find("CombinedTrackParticle") != std::string::npos) {
1042  //
1043  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Retrieving CombinedTrackParticles of the accepted muons");
1044  ppos_comb = muon_pos->trackParticle(xAOD::Muon::CombinedTrackParticle);
1045  pneg_comb = muon_neg->trackParticle(xAOD::Muon::CombinedTrackParticle);
1046 
1047  if (!ppos_comb || !pneg_comb){
1048  ATH_MSG_WARNING( "** IDPerfMonZmumu::execute ** CombinedTrackParticles are requested but they are not present. Exiting event.");
1049  return StatusCode::SUCCESS;
1050  }
1051  } // combined tracks
1052 
1053 
1054  // double check
1055  if (ppos_comb && pneg_comb) {
1056  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** successfull retrieval of muons as " << m_trackParticleName << ". ppos_comb & pneg_comb both exist");
1057  }
1058  else {
1059  ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** problems retrieving muons as " << m_trackParticleName <<". ppos_comb or pneg_comb are not available");
1060  }
1061 
1062 
1063  // vertex
1064  const EventContext& ctx = Gaudi::Hive::currentContext();
1065  SG::ReadHandle<xAOD::VertexContainer> vertices { m_vertexKey, ctx };
1066  for (const auto V : *vertices) {
1067  if (V->vertexType() == xAOD::VxType::VertexType::PriVtx) {
1068  // primaryVertex =V;
1069  ppos_comb_v = V;
1070  pneg_comb_v = V;
1071  break;
1072  }
1073  } // vertex
1074 
1075  // before continuing check both particles have vertex
1076  if (!ppos_comb_v || !pneg_comb_v){
1077  ATH_MSG_WARNING( "Some or all of the requested particles have no vertex. Exiting event");
1078  return StatusCode::SUCCESS;
1079  }
1080  } // if (muon_pos && muon_neg)
1081  else { // this is the else of --> if (muon_pos && muon_neg)
1082  ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** Could not find CombinedMuon pos/neg in event"
1083  << " Run: " << m_runNumber
1084  << " event: " << m_evtNumber
1085  << " Lumiblock: " << m_lumi_block );
1086  return StatusCode::SUCCESS;
1087  }
1088 
1089  //
1090  // If this point is reached -> there is a good mu+mu- pair and the muons have been associated to a vertex
1091  // So, ntuple can be filled
1092  //
1093  if ( m_xZmm.AcceptEvent() ) {
1094  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Going to fill ntuples for Run: " << m_runNumber
1095  << " event: " << m_evtNumber
1096  << " Lumiblock: " << m_lumi_block
1097  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ** some preliminaries are due though...");
1098 
1099  if (m_useTrackSelectionTool) {
1100  // The track selection is applied to the InnerDetectorTrackParticle of the muons
1101  if ( !m_selTool->accept(muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)) ) {
1102  ATH_MSG_DEBUG("Exiting because the ID segment of muon_pos do not pass the TrackSelection");
1103  return StatusCode::SUCCESS;
1104  }
1105  if ( !m_selTool->accept(muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)) ) {
1106  ATH_MSG_DEBUG("Exiting because the ID segment of muon_neg do not pass the TrackSelection");
1107  return StatusCode::SUCCESS;
1108  }
1109  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Good news ** pos and neg muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle) pass the trackSelection :)");
1110  }
1111  else {
1112  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track selection is not in use ");
1113  }
1114 
1115  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** >> before fill rec with default: " << m_trackParticleName << " tracks << ");
1116 
1117  if (m_storeZmumuNtuple) {
1118  // reset vectors
1119  this->ResetCommonNtupleVectors();
1120 
1121  // Fill Inner Detector Tree
1122  ATH_MSG_DEBUG("-- >> going to fill ID muons params << --");
1123  success_pos = FillRecParametersTP (muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1124  muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1125  muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->charge(),
1126  ppos_comb_v);
1127  success_neg = FillRecParametersTP (muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1128  muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1129  muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->charge(),
1130  pneg_comb_v);
1131 
1132  if (success_pos && success_neg) {
1133  // before filling the ntuple, extract the hits information. This is filled once and it is used for all track collections
1134  this->ExtractIDHitsInformation(muon_pos, muon_neg);
1135 
1136  // Fill ntuple
1137  if (m_IDTree != nullptr) {
1138  ATH_MSG_DEBUG("-- Filling m_IDTree ntuple " << m_IDTree->GetName() << " entry " << m_IDTree->GetEntries()
1139  << " for run: " << m_runNumber
1140  << " event: " << m_evtNumber
1141  << " Lumiblock: " << m_lumi_block
1142  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1143  }
1144  ATH_MSG_DEBUG("mu+ --> pxyz " << m_positive_px
1145  << ", " << m_positive_py
1146  << ", " << m_positive_pz
1147  << " pt: " << muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->pt()
1148  << " d0: " << m_positive_d0
1149  << " z0: " << m_positive_z0
1150  << " d0unc: " << m_positive_d0_err
1151  << " sigma_pt: " << m_positive_sigma_pt);
1152  ATH_MSG_DEBUG("mu- --> pxyz: " << m_negative_px
1153  << ", " << m_negative_py
1154  << ", " << m_negative_pz
1155  << " pt: " << muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)->pt()
1156  << " d0: " << m_negative_d0
1157  << " z0: " << m_negative_z0
1158  << " d0unc: " << m_negative_d0_err
1159  << " sigma_pt: " << m_negative_sigma_pt);
1160  // ntuple variables have been filled in FillRecParametersTP
1161  if (m_IDTree) m_IDTree->Fill();
1162 
1163  // Fill vectors for common ntuple
1164  m_IDTrack_pt.push_back(m_positive_pt);
1165  m_IDTrack_pt.push_back(m_negative_pt);
1166  m_IDTrack_eta.push_back(m_positive_eta);
1167  m_IDTrack_eta.push_back(m_negative_eta);
1168  m_IDTrack_phi.push_back(m_positive_phi);
1169  m_IDTrack_phi.push_back(m_negative_phi);
1170  m_IDTrack_d0.push_back(m_positive_d0);
1171  m_IDTrack_d0.push_back(m_negative_d0);
1172  m_IDTrack_z0.push_back(m_positive_z0);
1173  m_IDTrack_z0.push_back(m_negative_z0);
1174  m_IDTrack_qoverp.push_back(m_positive_qoverp);
1175  m_IDTrack_qoverp.push_back(m_negative_qoverp);
1176 
1177  m_IDTrack_sigma_pt.push_back(m_positive_sigma_pt);
1178  m_IDTrack_sigma_pt.push_back(m_negative_sigma_pt);
1179  m_IDTrack_sigma_d0.push_back(m_positive_d0_err);
1180  m_IDTrack_sigma_d0.push_back(m_negative_d0_err);
1181  m_IDTrack_sigma_z0.push_back(m_positive_z0_err);
1182  m_IDTrack_sigma_z0.push_back(m_negative_z0_err);
1183  m_IDTrack_sigma_qoverp.push_back(m_positive_sigma_qoverp);
1184  m_IDTrack_sigma_qoverp.push_back(m_negative_sigma_qoverp);
1185  }
1186  else {
1187  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** not filling IDTracks in combTree due to problems with muon_xxx->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)");
1188  }
1189  // End of fill ID Tree
1190 
1191  //
1192  // combined muons ntuple
1193  if ((!m_skipMS && m_combTree) || m_commonTree ) { // if skipMS -> no combined muons
1194  success_pos = FillRecParametersTP(muon_pos->trackParticle(xAOD::Muon::CombinedTrackParticle),
1195  muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1196  ppos_comb->charge(),
1197  ppos_comb_v);
1198  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** success_pos TP pt: " << m_positive_pt << " GeV");
1199  success_neg = FillRecParametersTP(muon_neg->trackParticle(xAOD::Muon::CombinedTrackParticle),
1200  muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1201  pneg_comb->charge(),
1202  pneg_comb_v);
1203  ATH_MSG_DEBUG("** IDPerfMonZmumu::excute ** success_neg TP pt: " << m_negative_pt << " GeV");
1204 
1205  if (success_pos && success_neg) {
1206  if (m_combTree != nullptr) {
1207  ATH_MSG_DEBUG("-- Filling m_combTree ntuple " << m_combTree->GetName() << " entry " << m_combTree->GetEntries()
1208  << " run: " << m_runNumber
1209  << " event: " << m_evtNumber
1210  << " Lumiblock: " << m_lumi_block
1211  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1212  }
1213  ATH_MSG_DEBUG("mu+ --> pxyz " << m_positive_px
1214  << ", " << m_positive_py
1215  << ", " << m_positive_pz
1216  << " pt: " << m_positive_pt
1217  << " d0: " << m_positive_d0
1218  << " z0: " << m_positive_z0
1219  << " d0unc: " << m_positive_d0_err);
1220  ATH_MSG_DEBUG("mu- --> pxyz: " << m_negative_px
1221  << ", " << m_negative_py
1222  << ", " << m_negative_pz
1223  << " pt: " << m_negative_pt
1224  << " d0: " << m_negative_d0
1225  << " z0: " << m_negative_z0
1226  << " d0unc: " << m_negative_d0_err);
1227  // ntuple variables have been filled in FillRecParameters
1228  if (m_combTree) m_combTree->Fill();
1229  }
1230  // Fill vectors for common ntuple
1231  m_CBTrack_pt.push_back(m_positive_pt);
1232  m_CBTrack_pt.push_back(m_negative_pt);
1233  m_CBTrack_eta.push_back(m_positive_eta);
1234  m_CBTrack_eta.push_back(m_negative_eta);
1235  m_CBTrack_phi.push_back(m_positive_phi);
1236  m_CBTrack_phi.push_back(m_negative_phi);
1237  m_CBTrack_d0.push_back(m_positive_d0);
1238  m_CBTrack_d0.push_back(m_negative_d0);
1239  m_CBTrack_z0.push_back(m_positive_z0);
1240  m_CBTrack_z0.push_back(m_negative_z0);
1241  m_CBTrack_qoverp.push_back(m_positive_qoverp);
1242  m_CBTrack_qoverp.push_back(m_negative_qoverp);
1243 
1244  m_CBTrack_sigma_pt.push_back(m_positive_sigma_pt);
1245  m_CBTrack_sigma_pt.push_back(m_negative_sigma_pt);
1246  m_CBTrack_sigma_d0.push_back(m_positive_d0_err);
1247  m_CBTrack_sigma_d0.push_back(m_negative_d0_err);
1248  m_CBTrack_sigma_z0.push_back(m_positive_z0_err);
1249  m_CBTrack_sigma_z0.push_back(m_negative_z0_err);
1250  m_CBTrack_sigma_qoverp.push_back(m_positive_sigma_qoverp);
1251  m_CBTrack_sigma_qoverp.push_back(m_negative_sigma_qoverp);
1252  } // if skipMS -> no combined muons
1253 
1254 
1255 
1256  // MS ntuple
1257  if (!m_skipMS && m_MSTree) { // if skipMS -> no MS tracks
1258  ATH_MSG_DEBUG("-- >> going to fill MS muons params << --");
1259  success_pos = FillRecParametersTP(m_xZmm.getMSTrack(m_xZmm.getPosMuon(ZmumuEvent::CB)),
1260  muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1261  ppos_comb->charge(),
1262  ppos_comb_v);
1263 
1264  success_neg = FillRecParametersTP(m_xZmm.getMSTrack(m_xZmm.getNegMuon(ZmumuEvent::CB)),
1265  muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle),
1266  pneg_comb->charge(),
1267  pneg_comb_v);
1268  if (success_pos && success_neg) {
1269  if (m_MSTree != nullptr) ATH_MSG_DEBUG("-- Filling m_MSTree " << m_MSTree->GetName() << " entry " << m_MSTree->GetEntries()
1270  << " run: " << m_runNumber
1271  << " event: " << m_evtNumber
1272  << " Lumiblock: " << m_lumi_block
1273  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1274  ATH_MSG_DEBUG("mu+ --> pxyz " << m_positive_px
1275  << ", " << m_positive_py
1276  << " pt: " << m_xZmm.getMSTrack(m_xZmm.getPosMuon(ZmumuEvent::CB))->pt()
1277  << " d0: " << m_positive_d0
1278  << " z0: " << m_positive_z0
1279  << " d0unc: " << m_positive_d0_err);
1280  ATH_MSG_DEBUG("mu- --> pxyz: " << m_negative_px
1281  << ", " << m_negative_py
1282  << " pt: " << m_xZmm.getMSTrack(m_xZmm.getNegMuon(ZmumuEvent::CB))->pt()
1283  << " d0: " << m_negative_d0
1284  << " z0: " << m_negative_z0
1285  << " d0unc: " << m_negative_d0_err);
1286  // ntuple variables have been filled in FillRecParametersTP
1287  if (m_MSTree) m_MSTree->Fill();
1288  }
1289  else {
1290  ATH_MSG_INFO("FAILED filling m_MSTree "
1291  << " for run: " << m_runNumber
1292  << " event: " << m_evtNumber
1293  << " Lumiblock: " << m_lumi_block);
1294  }
1295  // MS ntuple
1296  }
1297  } // if store Zmumu ntuple
1298 
1299  // changed refitting to combined particles since run II DESDM_ZMUMU did not store InDetTrackParticles
1300  if( m_doRefit ) {
1301  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Going to build TrackCollections: muonTrks, muonTrksRefit1 and muonTrksRefit2");
1302  TrackCollection* muonTrks = new TrackCollection(SG::OWN_ELEMENTS);
1303  TrackCollection* muonTrksRefit1 = new TrackCollection(SG::OWN_ELEMENTS);
1304  TrackCollection* muonTrksRefit2 = new TrackCollection(SG::OWN_ELEMENTS);
1305 
1306  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Going to refit and store the track parameters ");
1307  Trk::Track* defaultMuonTrk1{};
1308  Trk::Track* defaultMuonTrk2{};
1309  Trk::Track* refit1MuonTrk1{};
1310  Trk::Track* refit2MuonTrk1{};
1311  Trk::Track* refit1MuonTrk2{};
1312  Trk::Track* refit2MuonTrk2{};
1313 
1314  StatusCode fitStatus;
1315  //save default and refit track parameters
1316  const EventContext& ctx = Gaudi::Hive::currentContext();
1317  if( ppos_comb->track() ) {
1318  defaultMuonTrk1 = new Trk::Track(*ppos_comb->track());
1319 
1320  IegammaTrkRefitterTool::Cache fitResult{};
1321  fitStatus = m_TrackRefitter1->refitTrack( ctx, ppos_comb->track(), fitResult );
1322  if (fitStatus.isFailure()) {
1323  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit1 Failed for ppos_comb->track(). Skipping Event");
1324  return StatusCode::SUCCESS;
1325  } else {
1326  refit1MuonTrk1 = fitResult.refittedTrack.release();
1327  muonTrksRefit1->push_back(refit1MuonTrk1);
1328  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit1 Success of ppos_comb->track()."
1329  << " Original pt: " << ppos_comb->track()->perigeeParameters()->pT()
1330  << " track refit pt: " << refit1MuonTrk1->perigeeParameters()->pT() );
1331  }
1332 
1333 
1334  fitStatus = m_TrackRefitter2->refitTrack( ctx, ppos_comb->track(), fitResult );
1335  if (fitStatus.isFailure()) {
1336  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit2 Failed for ppos_comb->track(). Skipping Event");
1337  return StatusCode::SUCCESS;
1338  } else {
1339  refit2MuonTrk1 = fitResult.refittedTrack.release();
1340  muonTrksRefit2->push_back(refit2MuonTrk1);
1341  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit2 Success of ppos_comb->track()."
1342  << " Original pt: " << ppos_comb->track()->perigeeParameters()->pT()
1343  << " track refit pt: " << refit1MuonTrk1->perigeeParameters()->pT() );
1344  }
1345  }
1346 
1347  if( pneg_comb->track() ) {
1348  defaultMuonTrk2 = new Trk::Track(*pneg_comb->track());
1349 
1350  IegammaTrkRefitterTool::Cache fitResult {};
1351  fitStatus = m_TrackRefitter1->refitTrack( ctx, pneg_comb->track(), fitResult);
1352  if (fitStatus.isFailure()) {
1353  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit1 Failed. Skipping Event");
1354  return StatusCode::SUCCESS;
1355  } else {
1356  refit1MuonTrk2 = fitResult.refittedTrack.release();
1357  muonTrksRefit1->push_back(refit1MuonTrk2);
1358  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit1 Success of pneg_comb->track()."
1359  << " Original pt: " << pneg_comb->track()->perigeeParameters()->pT()
1360  << " track refit pt: " << refit1MuonTrk2->perigeeParameters()->pT() );
1361  }
1362 
1363 
1364  fitStatus = m_TrackRefitter2->refitTrack( ctx, pneg_comb->track(), fitResult );
1365  if (fitStatus.isFailure()) {
1366  ATH_MSG_DEBUG("Track Refit2 Failed. Skipping Event");
1367  return StatusCode::SUCCESS;
1368  } else {
1369  refit2MuonTrk2 = fitResult.refittedTrack.release();
1370  muonTrksRefit2->push_back(refit2MuonTrk2);
1371  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** Track Refit2 Success of pneg_comb->track()."
1372  << " Original pt: " << pneg_comb->track()->perigeeParameters()->pT()
1373  << " track refit pt: " << refit2MuonTrk2->perigeeParameters()->pT() );
1374  }
1375 
1376  if (muonTrksRefit1->size() != 2) ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** WARNING ** size of muonTrksRefit1: " << muonTrksRefit1->size());
1377  if (muonTrksRefit2->size() != 2) ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** WARNING ** size of muonTrksRefit2: " << muonTrksRefit2->size());
1378  }
1379 
1380  //save tracks to storegrate, they can be used by InDetAlignmentMonitoring
1381  muonTrks->push_back(defaultMuonTrk1);
1382  muonTrks->push_back(defaultMuonTrk2);
1383 
1384  StatusCode sc = evtStore()->record(muonTrks, m_outputTracksName);
1385  if (sc.isSuccess()) {
1386  ATH_MSG_DEBUG ("Stored "<< muonTrks->size() << " " << m_outputTracksName <<" into StoreGate");
1387  }
1388  else{
1389  ATH_MSG_WARNING ("Failed storing " << m_outputTracksName);
1390  }
1391 
1392  if (muonTrksRefit1->size() > 1) { // keep track collection if at least 2 muons were found
1393  sc = evtStore()->record(muonTrksRefit1, m_outputTracksName + "Refit1");
1394  if (sc.isSuccess()) {
1395  ATH_MSG_DEBUG ("Stored "<< muonTrksRefit1->size() << " " << m_outputTracksName + "Refit1" << " into StoreGate");
1396  } else {
1397  ATH_MSG_WARNING ("Failed storing " << m_outputTracksName + "Refit1");
1398  }
1399  }
1400 
1401  if (muonTrksRefit2->size() > 1) { // keep track collection if at least 2 muons were found
1402  sc = evtStore()->record(muonTrksRefit2, m_outputTracksName + "Refit2");
1403  if (sc.isSuccess()) {
1404  ATH_MSG_DEBUG ("Stored "<< muonTrksRefit2->size() << " " << m_outputTracksName + "Refit2" << " into StoreGate");
1405  } else {
1406  ATH_MSG_WARNING ("Failed storing " << m_outputTracksName + "Refit2");
1407  }
1408  }
1409 
1410 
1411  //fill refit1 ID parameters
1412  if (muonTrksRefit1->size()<2) {
1413  ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** Refit1 muon tracks are missing!");
1414  }
1415  else {
1416  ATH_MSG_DEBUG("** IDPerfMonZmumu::execute ** going to fill refit1tree ");
1417  success_pos = FillRecParametersSimple (refit1MuonTrk1, ppos_comb->charge(), ppos_comb_v);
1418  success_neg = FillRecParametersSimple (refit1MuonTrk2, pneg_comb->charge(), pneg_comb_v);
1419 
1420  if (m_storeZmumuNtuple) {
1421  if (success_pos && success_neg) {
1422  if (m_refit1Tree) {
1423  ATH_MSG_DEBUG("-- Filling ntuple " << m_refit1Tree->GetName() << " entry " << m_refit1Tree->GetEntries()
1424  << " for run: " << m_runNumber
1425  << " event: " << m_evtNumber
1426  << " Lumiblock: " << m_lumi_block
1427  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1428  }
1429  ATH_MSG_DEBUG("Negative p: (" << m_negative_px << ", "
1430  << m_negative_py << ", "
1431  << m_negative_pz << ") "
1432  << " d0: " << m_negative_d0
1433  << " z0: " << m_negative_z0
1434  << " sigma_pt: " << m_positive_sigma_pt);
1435  ATH_MSG_DEBUG("Positive p: (" << m_positive_px << ","
1436  << m_positive_py << ","
1437  << m_positive_pz << ") "
1438  << " d0: " << m_positive_d0
1439  << " z0: " << m_positive_z0
1440  << " sigma_pt: " << m_negative_sigma_pt);
1441  if (m_refit1Tree) {
1442  m_refit1Tree->Fill();
1443  }
1444  // Fill vectors for common ntuple
1445  m_Refit1_pt.push_back(m_positive_pt);
1446  m_Refit1_pt.push_back(m_negative_pt);
1447  m_Refit1_eta.push_back(m_positive_eta);
1448  m_Refit1_eta.push_back(m_negative_eta);
1449  m_Refit1_phi.push_back(m_positive_phi);
1450  m_Refit1_phi.push_back(m_negative_phi);
1451  m_Refit1_d0.push_back(m_positive_d0);
1452  m_Refit1_d0.push_back(m_negative_d0);
1453  m_Refit1_z0.push_back(m_positive_z0);
1454  m_Refit1_z0.push_back(m_negative_z0);
1455 
1456  m_Refit1_sigma_pt.push_back(m_positive_sigma_pt);
1457  m_Refit1_sigma_pt.push_back(m_negative_sigma_pt);
1458  m_Refit1_sigma_d0.push_back(m_positive_d0_err);
1459  m_Refit1_sigma_d0.push_back(m_negative_d0_err);
1460  m_Refit1_sigma_z0.push_back(m_positive_z0_err);
1461  m_Refit1_sigma_z0.push_back(m_negative_z0_err);
1462  } // if (success_pos && success_neg)
1463  } // if (m_storeZmumuNtuple)
1464  } // enough refit1 tracks
1465 
1466  //fill refit2 ID parameters
1467  if (muonTrksRefit2->size()<2) {
1468  ATH_MSG_WARNING("** IDPerfMonZmumu::execute ** Refit2 muon tracks are missing!");
1469  }
1470  else{
1471  ATH_MSG_DEBUG("-- >> going to fill refit2params << --");
1472  success_pos = FillRecParametersSimple (refit2MuonTrk1, ppos_comb->charge(), ppos_comb_v);
1473  success_neg = FillRecParametersSimple (refit2MuonTrk2, pneg_comb->charge(), pneg_comb_v);
1474 
1475  if (m_storeZmumuNtuple) {
1476  if (success_pos && success_neg) {
1477  if (m_refit2Tree) {
1478  ATH_MSG_DEBUG("-- Filling " << m_refit2Tree->GetName() << " entry " << m_refit2Tree->GetEntries()
1479  << " run: " << m_runNumber
1480  << " event: " << m_evtNumber
1481  << " Lumiblock: " << m_lumi_block
1482  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1483  }
1484  ATH_MSG_DEBUG("Negative p: (" << m_negative_px << ", "
1485  << m_negative_py << ", "
1486  << m_negative_pz << ") "
1487  << " d0: " << m_negative_d0
1488  << " z0: " << m_negative_z0
1489  << " sigma_pt: " << m_positive_sigma_pt);
1490  ATH_MSG_DEBUG("Positive p: (" << m_positive_px << ","
1491  << m_positive_py << ","
1492  << m_positive_pz << ") "
1493  << " d0: " << m_positive_d0
1494  << " z0: " << m_positive_z0
1495  << " sigma_pt: " << m_negative_sigma_pt);
1496  if (m_refit2Tree) {
1497  m_refit2Tree->Fill();
1498  }
1499  // Fill vectors for common ntuple
1500  m_Refit2_pt.push_back(m_positive_pt);
1501  m_Refit2_pt.push_back(m_negative_pt);
1502  m_Refit2_eta.push_back(m_positive_eta);
1503  m_Refit2_eta.push_back(m_negative_eta);
1504  m_Refit2_phi.push_back(m_positive_phi);
1505  m_Refit2_phi.push_back(m_negative_phi);
1506  m_Refit2_d0.push_back(m_positive_d0);
1507  m_Refit2_d0.push_back(m_negative_d0);
1508  m_Refit2_z0.push_back(m_positive_z0);
1509  m_Refit2_z0.push_back(m_negative_z0);
1510 
1511  m_Refit2_sigma_pt.push_back(m_positive_sigma_pt);
1512  m_Refit2_sigma_pt.push_back(m_negative_sigma_pt);
1513  m_Refit2_sigma_d0.push_back(m_positive_d0_err);
1514  m_Refit2_sigma_d0.push_back(m_negative_d0_err);
1515  m_Refit2_sigma_z0.push_back(m_positive_z0_err);
1516  m_Refit2_sigma_z0.push_back(m_negative_z0_err);
1517  } // if (success_pos && success_neg)
1518  } // if (m_storeZmumuNtuple)
1519  } // enough refit2 tracks
1520 
1521  ATH_MSG_DEBUG("Execute() All NTUPLES filled Run: " << m_runNumber << " event: " << m_evtNumber << " mass: " << m_xZmm.GetInvMass() << " GeV ");
1522  }
1523  } // closing -> if ( m_xZmm.AcceptEvent() )
1524 
1525  if ( !m_xZmm.AcceptEvent() ) {
1526  // no good muon pair found
1527  //failed cuts, continue to next event
1528  ATH_MSG_DEBUG ("** IDPerfMonZmumu::execute ** No good muon pair found. Leaving Execute(). Run: " << m_runNumber << " event: " << m_evtNumber);
1529  return StatusCode::SUCCESS;
1530  }
1531 
1532  //
1533  // fill truth event iformation even when the reco event has not passed
1534  //
1535  if (m_isMC) {
1536  bool truthStatusIsGood = true;
1537  if (FillTruthParameters(ppos_comb).isFailure()){
1538  truthStatusIsGood = false;
1539  ATH_MSG_WARNING("Failed to fill truth parameters - skipping event");
1540  }
1541  if (FillTruthParameters(pneg_comb).isFailure()){
1542  truthStatusIsGood = false;
1543  ATH_MSG_WARNING("Failed to fill truth parameters - skipping event");
1544  }
1545  if (truthStatusIsGood) {
1546  ATH_MSG_DEBUG ("-- Filling " << m_truthTree->GetName() << " entry " << m_truthTree->GetEntries()
1547  << " run: " << m_runNumber
1548  << " event: " << m_evtNumber
1549  << " Lumiblock: " << m_lumi_block
1550  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1551  ATH_MSG_DEBUG ("Negative p: (" << m_negative_px << ", "
1552  << m_negative_py << ", "
1553  << m_negative_pz << ") "
1554  << " d0: " << m_negative_d0
1555  << " z0: " << m_negative_z0
1556  << " parent: " << m_negative_parent);
1557  ATH_MSG_DEBUG ("Positive p: (" << m_positive_px << ","
1558  << m_positive_py << ","
1559  << m_positive_pz << ") "
1560  << " d0: " << m_positive_d0
1561  << " z0: " << m_positive_z0
1562  << " parent: " << m_positive_parent);
1563 
1564  if (m_storeZmumuNtuple && m_truthTree) m_truthTree->Fill();
1565  m_Truth_pt.push_back(m_positive_pt);
1566  m_Truth_pt.push_back(m_negative_pt);
1567  m_Truth_eta.push_back(m_positive_eta);
1568  m_Truth_eta.push_back(m_negative_eta);
1569  m_Truth_phi.push_back(m_positive_phi);
1570  m_Truth_phi.push_back(m_negative_phi);
1571  m_Truth_d0.push_back(m_positive_d0);
1572  m_Truth_d0.push_back(m_negative_d0);
1573  m_Truth_z0.push_back(m_positive_z0);
1574  m_Truth_z0.push_back(m_negative_z0);
1575  m_Truth_qoverp.push_back(m_positive_qoverp);
1576  m_Truth_qoverp.push_back(m_negative_qoverp);
1577  m_Truth_parent.push_back(m_positive_parent);
1578  m_Truth_parent.push_back(m_negative_parent);
1579 
1580  } // truth info properly filled
1581  else {
1582  ATH_MSG_DEBUG("FAILED filling m_truthTree "
1583  << " for run: " << m_runNumber
1584  << " event: " << m_evtNumber
1585  << " Lumiblock: " << m_lumi_block);
1586  }
1587  } // if (m_isMC)
1588 
1589  // fill common tree
1590  if (m_commonTree ) {
1591  // fill ntuple if some of the collections is filled
1592  bool dofill = false;
1593  if (m_IDTrack_pt.size() >= 2) dofill = true;
1594  if (m_CBTrack_pt.size() >= 2) dofill = true;
1595  if (m_Refit1_pt.size() >= 2) dofill = true;
1596  if (m_Refit2_pt.size() >= 2) dofill = true;
1597  if (m_Truth_pt.size() >= 2) dofill = true;
1598 
1599  if (dofill) {
1600  ATH_MSG_DEBUG("-- Filling m_commonTree " << m_commonTree->GetName() << " entry " << m_commonTree->GetEntries()
1601  << " run: " << m_runNumber
1602  << " event: " << m_evtNumber
1603  << " Lumiblock: " << m_lumi_block
1604  << " Invariant mass = " << m_xZmm.GetInvMass() << " GeV ");
1605  m_commonTree->Fill();
1606  }
1607  else {
1608  ATH_MSG_DEBUG("-- Filling m_commonTree " << m_commonTree->GetName() << " FAILED for "
1609  << " run: " << m_runNumber
1610  << " event: " << m_evtNumber
1611  << " Lumiblock: " << m_lumi_block);
1612  }
1613  }
1614 
1615  ATH_MSG_DEBUG(" --IDPerfMonZmumu::execute-- event completed -- Run: " << m_runNumber << " event: " << m_evtNumber);
1616 
1617  /* ***********************************************************
1618  * after all, let's make the collection for ALL MUON ID Tracks
1619  * ***********************************************************/
1620 
1621  ATH_MSG_DEBUG("IDTracks monitoring..");
1622  int nTracks = 0;
1623  TrackCollection* IDTracks = new TrackCollection(SG::OWN_ELEMENTS);
1624 
1625  // DIFFERENT RETRIEVAL
1626  const xAOD::MuonContainer* muons = PerfMonServices::getContainer<xAOD::MuonContainer>( PerfMonServices::MUON_COLLECTION );
1627  if(muons){
1628  for (auto muon : *muons) {
1629  const xAOD::TrackParticle* tp = muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
1630  if(!tp) {
1631  ATH_MSG_DEBUG(" - tpb = "<< tp << " -> is null? " << (!tp));
1632  continue;
1633  }
1634  const Trk::Track* t = tp->track();
1635  if ( !t ) {
1636  ATH_MSG_DEBUG(" - tpb does not have track ");
1637  continue;
1638  }
1639  const Trk::Perigee* tPerigee = t->perigeeParameters() ;
1640  if ( !tPerigee ) {
1641  ATH_MSG_DEBUG(" - t does not have perigree ");
1642  continue;
1643  }
1644  IDTracks->push_back ( new Trk::Track (*t));
1645  nTracks++;
1646  }
1647  }
1648  else ATH_MSG_WARNING ("Could not retrieve Muon container");
1649 
1650  ATH_MSG_DEBUG(" --> nTracks = " << nTracks);
1651 
1652  StatusCode scid = evtStore()->record(IDTracks, "IDTracks");
1653  if (scid.isSuccess()) {
1654  ATH_MSG_DEBUG ("Stored "<< IDTracks->size() << " IDTracks into StoreGate");
1655  }
1656  else{
1657  ATH_MSG_WARNING ("Failed storing IDTracks");
1658  }
1659 
1660  /*********************************************************
1661  * ..finish
1662  ********************************************************/
1663 
1664  return StatusCode::SUCCESS;
1665 }

◆ ExtractIDHitsInformation()

void IDPerfMonZmumu::ExtractIDHitsInformation ( const xAOD::Muon *  muon_pos,
const xAOD::Muon *  muon_neg 
)
private

Definition at line 2773 of file IDPerfMonZmumu.cxx.

2774 {
2775  // hits info
2776  // positive Muon
2777  const xAOD::TrackParticle* IDTrkMuPos = muon_pos->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
2778  const xAOD::TrackParticle* IDTrkMuNeg = muon_neg->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
2779 
2780  int nBLhits, nhitsPIX, nhitsSCT, nhitsTRT, nContribPixLayers;
2781  int nPIXholes, nSCTholes;
2782  if (IDTrkMuPos && IDTrkMuNeg) { // make sure both summaries are available
2783  uint8_t dummy(-1);
2784  nBLhits = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfBLayerHits ) ? dummy :-1;
2785  nhitsPIX = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfPixelHits ) ? dummy :-1;
2786  nhitsSCT = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfSCTHits ) ? dummy :-1;
2787  nhitsTRT = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfTRTHits ) ? dummy :-1;
2788  nContribPixLayers = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfContribPixelLayers )? dummy :-1;
2789 
2790  nPIXholes = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfPixelHoles )? dummy :-1;
2791  nSCTholes = IDTrkMuPos->summaryValue( dummy, xAOD::numberOfSCTHoles )? dummy :-1;
2792 
2793 
2794  m_nBLhits.push_back(nBLhits);
2795  m_nPIXhits.push_back(nhitsPIX);
2796  m_nSCThits.push_back(nhitsSCT);
2797  m_nTRThits.push_back(nhitsTRT);
2798 
2799  ATH_MSG_DEBUG (" -- mu_pos -- HITS --"
2800  << " nBLhits: " << nBLhits
2801  << " nhitsPIX: " << nhitsPIX
2802  << " nPIXLayers: " << nContribPixLayers
2803  << " nhitsSCT: " << nhitsSCT
2804  << " Silicon holes: " << nPIXholes + nSCTholes
2805  << " nhitsTRT: " << nhitsTRT);
2806 
2807  nBLhits = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfBLayerHits ) ? dummy :-1;
2808  nhitsPIX = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfPixelHits ) ? dummy :-1;
2809  nhitsSCT = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfSCTHits ) ? dummy :-1;
2810  nhitsTRT = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfTRTHits ) ? dummy :-1;
2811  nContribPixLayers = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfContribPixelLayers )? dummy :-1;
2812  nPIXholes = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfPixelHoles )? dummy :-1;
2813  nSCTholes = IDTrkMuNeg->summaryValue( dummy, xAOD::numberOfSCTHoles )? dummy :-1;
2814 
2815  m_nBLhits.push_back(nBLhits);
2816  m_nPIXhits.push_back(nhitsPIX);
2817  m_nSCThits.push_back(nhitsSCT);
2818  m_nTRThits.push_back(nhitsTRT);
2819 
2820  ATH_MSG_DEBUG (" -- mu_neg -- HITS --"
2821  << " nBLhits: " << nBLhits
2822  << " nhitsPIX: " << nhitsPIX
2823  << " nPIXLayers: " << nContribPixLayers
2824  << " nhitsSCT: " << nhitsSCT
2825  << " Silicon holes: " << nPIXholes + nSCTholes
2826  << " nhitsTRT: " << nhitsTRT);
2827 
2828  }
2829  return;
2830 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ FillRecParameters()

StatusCode IDPerfMonZmumu::FillRecParameters ( const Trk::Track *  track,
const xAOD::TrackParticle *  trackp_for_unbias,
double  charge,
const xAOD::Vertex *  vertex,
const EventContext &  ctx 
)
private

Definition at line 1810 of file IDPerfMonZmumu.cxx.

1811 {
1812  if (!track){
1813  ATH_MSG_DEBUG("* FillRecParameters * Empty Track: track. Skipping.");
1814  return StatusCode::FAILURE;
1815  }
1816 
1817  if (m_doRemoval && !trackp_for_unbias && !m_skipMS) {
1818  ATH_MSG_DEBUG("* FillRecParameters * Empty Track: trackp_for_unbias. Skipping.");
1819  return StatusCode::FAILURE;
1820  }
1821 
1822  const Trk::Perigee* trkPerigee = track->perigeeParameters();
1823  const Trk::Perigee* trk_for_unbiasPerigee = nullptr;
1824  if (!m_skipMS) trk_for_unbiasPerigee = &(trackp_for_unbias->perigeeParameters());
1825 
1826  double px = 0;
1827  double py = 0;
1828  double pt = 0;
1829  double pz = 0;
1830  double phi= 0;
1831  double eta= 0;
1832  double d0 = 0;
1833  double z0 = 0;
1834 
1835  double d0_err = 999.;
1836  double z0_err = 999.;
1837 
1838  double PVd0 = 0;
1839  double PVz0 = 0;
1840  double PVd0res = 0;
1841  double PVz0res = 0;
1842 
1843 
1844  if (trkPerigee != nullptr){
1845  double qOverP = trkPerigee->parameters()[Trk::qOverP];
1846  if (qOverP) {
1847  px = trkPerigee->momentum().x();
1848  py = trkPerigee->momentum().y();
1849  pt = std::abs(trkPerigee->pT());
1850  pz = trkPerigee->momentum().z();
1851  phi= trkPerigee->parameters()[Trk::phi];
1852  eta= trkPerigee->eta();
1853  d0 = trkPerigee->parameters()[Trk::d0];
1854  z0 = trkPerigee->parameters()[Trk::z0];
1855  d0_err = Amg::error(*trkPerigee->covariance(),Trk::d0);
1856  z0_err = Amg::error(*trkPerigee->covariance(),Trk::z0);
1857  }
1858  }
1859 
1860  // access beam spot and extrapolate track till there
1861  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandleRec { m_beamSpotKey, ctx };
1862  auto beamline = m_trackToVertexTool->GetBeamLine(beamSpotHandleRec.cptr());
1863 
1864  auto trackBLtemp = m_trackToVertexTool->trackAtBeamline(ctx, *track , beamline.get() );
1865  const Trk::AtaStraightLine* atBL = dynamic_cast<const Trk::AtaStraightLine*>(trackBLtemp.get());
1866 
1867  if (atBL){
1868  double qOverP = atBL->parameters()[Trk::qOverP];
1869  if(qOverP){
1870  px = atBL->momentum().x();
1871  py = atBL->momentum().y();
1872  pt = std::abs(atBL->pT());
1873  pz = atBL->momentum().z();
1874  eta= trkPerigee->eta();
1875  phi= trkPerigee->parameters()[Trk::phi];
1876  d0 = atBL->parameters()[Trk::d0];
1877  z0 = atBL->parameters()[Trk::z0];
1878  // z0_err = Amg::error(*trkPerigee->covariance(),Trk::z0); //->Why not?
1879  // d0_err = Amg::error(*trkPerigee->covariance(),Trk::d0); //->Why not?
1880  }
1881  delete atBL;
1882  }
1883  else {
1884  ATH_MSG_WARNING("FillRecParameters::Failed extrapolation to the BeamLine");
1885  }
1886 
1887  Amg::Vector3D position = beamSpotHandleRec->beamPos();
1888  TLorentzVector vtrack = TLorentzVector (trkPerigee->momentum().x(),
1889  trkPerigee->momentum().y(),
1890  trkPerigee->momentum().z(),
1891  trkPerigee->momentum().mag());
1892  float trkd0 = trkPerigee->parameters()[Trk::d0];
1893  float trkz0 = trkPerigee->parameters()[Trk::z0];
1894  float bsX = position.x();
1895  float bsY = position.y();
1896  float bsZ = position.z();
1897  float btiltX = beamSpotHandleRec->beamTilt(0);
1898  float btiltY = beamSpotHandleRec->beamTilt(1);
1899  // correct the track parameters for the beamspot position
1900  float beamX = bsX + std::tan(btiltX) * (trkz0-bsZ);
1901  float beamY = bsY + std::tan(btiltY) * (trkz0-bsZ);
1902  float beamD0 = ( -std::sin(vtrack.Phi())*beamX + std::cos(vtrack.Phi())*beamY );
1903  float d0bscorr = trkd0 - beamD0;
1904  float z0bscorr = trkz0 - bsZ;
1905 
1906  if(m_doIP && vertex){ //I assume that the vertex is the same of the original track
1907  std::unique_ptr<Trk::ImpactParametersAndSigma> iPandSigma(nullptr);
1908  if (!m_skipMS) iPandSigma = m_trackToVertexIPEstimator->estimate(trk_for_unbiasPerigee,trkPerigee,vertex,m_doRemoval);
1909  else iPandSigma = m_trackToVertexIPEstimator->estimate(trkPerigee,vertex);
1910  if( iPandSigma==0 ){
1911  ATH_MSG_WARNING ("FillRecParameters::trackToVertexIPEstimator failed !");
1912  return StatusCode::FAILURE;
1913  }
1914  else{
1915  ATH_MSG_DEBUG("FillRecParameters::trackToVertexIPEstimator success !");
1916  PVd0 = iPandSigma->IPd0;
1917  PVd0res = iPandSigma->PVsigmad0;
1918  //d0res = iPandSigma->sigmad0; //-> ?
1919  PVz0 = iPandSigma->IPz0;
1920  PVz0res = iPandSigma->PVsigmaz0;
1921  //z0res = iPandSigma->sigmaz0; //-> ?
1922 
1923  if (vertex) {
1924  ATH_MSG_INFO(" FillRecParameters::trackToVertexIPEstimator vertex does exist ");
1925  m_pv_x = vertex->x();
1926  m_pv_y = vertex->y();
1927  m_pv_z = vertex->z();
1928  m_nTrkInVtx = vertex->nTrackParticles();
1929  }
1930 
1931  }
1932  }
1933 
1934  if (charge == 1) {
1935  m_positive_px = px;
1936  m_positive_py = py;
1937  m_positive_pt = pt;
1938  m_positive_pz = pz;
1939  m_positive_phi= phi;
1940  m_positive_eta= eta;
1941  m_positive_z0 = z0;
1942  m_positive_d0 = d0;
1943  m_positive_z0_manualBS = z0bscorr;
1944  m_positive_d0_manualBS = d0bscorr;
1945  m_positive_d0_err = d0_err;
1946  m_positive_z0_err = z0_err;
1947  if(m_doIP){
1948  m_positive_z0_PV = PVz0;
1949  m_positive_d0_PV = PVd0;
1950  m_positive_z0_PVerr = PVz0res;
1951  m_positive_d0_PVerr = PVd0res;
1952  }
1953  ATH_MSG_DEBUG("(Filled charge == 1 ) (reco)-> px : "<< px <<" py: "<<py <<" pz: "<<pz <<" d0: "<<d0<<" z0: "<< z0);
1954  }
1955  if (charge == -1) {
1956  m_negative_px = px;
1957  m_negative_py = py;
1958  m_negative_pt = pt;
1959  m_negative_pz = pz;
1960  m_negative_phi= phi;
1961  m_negative_eta= eta;
1962  m_negative_z0 = z0;
1963  m_negative_d0 = d0;
1964  m_negative_z0_manualBS = z0bscorr;
1965  m_negative_d0_manualBS = d0bscorr;
1966  m_negative_d0_err = d0_err;
1967  m_negative_z0_err = z0_err;
1968  if(m_doIP){
1969  m_negative_z0_PV = PVz0;
1970  m_negative_d0_PV = PVd0;
1971  m_negative_z0_PVerr = PVz0res;
1972  m_negative_d0_PVerr = PVd0res;
1973  }
1974  ATH_MSG_DEBUG("(Filled charge == -1 ) (reco)-> px : "<< px <<" py: "<<py <<" pz: "<<pz <<" d0: "<<d0<<" z0: "<<z0 );
1975  }
1976 
1977  return StatusCode::SUCCESS;
1978 }

◆ FillRecParametersSimple()

StatusCode IDPerfMonZmumu::FillRecParametersSimple ( const Trk::Track *  track,
float  charge,
const xAOD::Vertex *  vertex 
)
private

Definition at line 1980 of file IDPerfMonZmumu.cxx.

1981 {
1982  if (!track){
1983  ATH_MSG_DEBUG("* FillRecParametersSimple * Empty Track: track. Skipping.");
1984  return StatusCode::FAILURE;
1985  }
1986 
1987  const Trk::Perigee* trkPerigee = track->perigeeParameters();
1988  if (not trkPerigee) {
1989  ATH_MSG_ERROR("trkPerigee pointer is null in IDPerfMonZmumu::FillRecParametersSimple");
1990  return StatusCode::FAILURE;
1991  }
1992  double px = 0;
1993  double py = 0;
1994  double pt = 0;
1995  double pz = 0;
1996  double phi= 0;
1997  double eta= 0;
1998 
1999  double d0 = 0;
2000  double z0 = 0;
2001  double d0_err = 999.;
2002  double z0_err = 999.;
2003 
2004  //
2005  double qOverP = trkPerigee->parameters()[Trk::qOverP];
2006  if (qOverP) {
2007  px = trkPerigee->momentum().x();
2008  py = trkPerigee->momentum().y();
2009  pt = std::abs(trkPerigee->pT());
2010  pz = trkPerigee->momentum().z();
2011  phi= trkPerigee->parameters()[Trk::phi];
2012  eta= trkPerigee->eta();
2013  d0 = trkPerigee->parameters()[Trk::d0];
2014  z0 = trkPerigee->parameters()[Trk::z0];
2015  d0_err = Amg::error(*trkPerigee->covariance(),Trk::d0);
2016  z0_err = Amg::error(*trkPerigee->covariance(),Trk::z0);
2017  }
2018 
2019  SG::ReadHandle<xAOD::EventInfo> eventInfo (m_EventInfoKey, getContext());
2020  Amg::Vector3D position (eventInfo->beamPosX(), eventInfo->beamPosY(), eventInfo->beamPosZ());
2021  TLorentzVector vtrack = TLorentzVector (trkPerigee->momentum().x(),
2022  trkPerigee->momentum().y(),
2023  trkPerigee->momentum().z(),
2024  trkPerigee->momentum().mag());
2025  float trkd0 = trkPerigee->parameters()[Trk::d0];
2026  float trkz0 = trkPerigee->parameters()[Trk::z0];
2027  float bsX = position.x();
2028  float bsY = position.y();
2029  float bsZ = position.z();
2030  float btiltX = eventInfo->beamTiltXZ();
2031  float btiltY = eventInfo->beamTiltYZ();
2032  // correct the track parameters for the beamspot position
2033  float beamX = bsX + std::tan(btiltX) * (trkz0-bsZ);
2034  float beamY = bsY + std::tan(btiltY) * (trkz0-bsZ);
2035  float beamD0 = ( -std::sin(vtrack.Phi())*beamX + std::cos(vtrack.Phi())*beamY );
2036  float d0bscorr = trkd0 - beamD0;
2037  float z0bscorr = trkz0 - bsZ - vertex->z();
2038 
2039  if (charge == 1) {
2040  m_positive_px = px;
2041  m_positive_py = py;
2042  m_positive_pt = pt;
2043  m_positive_pz = pz;
2044  m_positive_phi= phi;
2045  m_positive_eta= eta;
2046  m_positive_z0 = z0bscorr;
2047  m_positive_d0 = d0bscorr;
2048  m_positive_z0_manualBS = z0bscorr;
2049  m_positive_d0_manualBS = d0bscorr;
2050  m_positive_d0_err = d0_err;
2051  m_positive_z0_err = z0_err;
2052  }
2053  if (charge == -1) {
2054  m_negative_px = px;
2055  m_negative_py = py;
2056  m_negative_pt = pt;
2057  m_negative_pz = pz;
2058  m_negative_phi= phi;
2059  m_negative_eta= eta;
2060  m_negative_z0 = z0bscorr;
2061  m_negative_d0 = d0bscorr;
2062  m_negative_z0_manualBS = z0bscorr;
2063  m_negative_d0_manualBS = d0bscorr;
2064  m_negative_d0_err = d0_err;
2065  m_negative_z0_err = z0_err;
2066  }
2067 
2068  ATH_MSG_DEBUG("-- FillRecParametersSimple -- charge " << charge << " pt: " << pt << " d0: " << d0 << " z0: " << z0);
2069 
2070  return StatusCode::SUCCESS;
2071 }

◆ FillRecParametersTP()

StatusCode IDPerfMonZmumu::FillRecParametersTP ( const xAOD::TrackParticle *  trackp,
const xAOD::TrackParticle *  trackp_for_unbias,
double  charge,
const xAOD::Vertex *  vertex = nullptr 
)
private

Definition at line 1668 of file IDPerfMonZmumu.cxx.

1672 {
1673  if (!trackp){
1674  //ATH_MSG_WARNING("Empty Trackparticle. Skipping.");
1675  return StatusCode::FAILURE;
1676  }
1677 
1678  if (m_doRemoval && !trackp_for_unbias && !m_skipMS){
1679  return StatusCode::FAILURE;
1680  }
1681 
1682  double px = 0;
1683  double py = 0;
1684  double pt = 0;
1685  double pz = 0;
1686  double phi= 0;
1687  double eta= 0;
1688  double d0 = 0;
1689  double z0 = 0;
1690  double d0res = 0;
1691  double z0res = 0;
1692  double PVd0res = 0;
1693  double PVz0res = 0;
1694  double PVd0 = 0;
1695  double PVz0 = 0;
1696  double sigma_pt = 0;
1697  double qoverp = 0;
1698  double sigma_qOverP = 1.; // use a large value by default as 0 is meaningless
1699 
1700 
1701  px = trackp->p4().Px();
1702  py = trackp->p4().Py();
1703  pt = trackp->p4().Pt();
1704  pz = trackp->p4().Pz();
1705  phi= trackp->p4().Phi();
1706  eta= trackp->p4().Eta();
1707  d0 = trackp->d0();
1708  z0 = trackp->z0();
1709  qoverp = trackp->qOverP();
1710 
1711  d0res = std::sqrt(trackp->definingParametersCovMatrix()(Trk::d0,Trk::d0));
1712  z0res = std::sqrt(trackp->definingParametersCovMatrix()(Trk::z0,Trk::z0));
1713  sigma_qOverP = std::sqrt(trackp->definingParametersCovMatrix()(Trk::qOverP,Trk::qOverP));
1714  double sigma_theta = std::sqrt(trackp->definingParametersCovMatrix()(Trk::theta,Trk::theta));
1715 
1716  // computing sigma_pt
1717  // pt = sin(theta) / qOverP --> sigma(pt) = (sin(theta)/ qOverP^2) x sigma(qOverP) // neglecting sigma(sin(theta))
1718  double sigma_pt_term1 = (sin(trackp->theta()) / pow(qoverp,2)) * sigma_qOverP;
1719  double sigma_pt_term2 = (1./qoverp) * cos(trackp->theta()) * sigma_theta;
1720  double sigma_pt_term3 = (cos(trackp->theta()) / pow(qoverp,2)) * sigma_theta * sigma_qOverP;
1721  sigma_pt = sqrt( pow(sigma_pt_term1,2) + pow(sigma_pt_term2,2) + 2 * sigma_pt_term3 * trackp->definingParametersCovMatrix()(Trk::qOverP,Trk::theta));
1722 
1723  //
1724  if (vertex == nullptr) {
1725  ATH_MSG_WARNING("in FillRecParametersTP. WARNING: Vertex is NULL");
1726  return StatusCode::FAILURE;
1727  }
1728  if (!m_trackToVertexIPEstimator) {
1729  ATH_MSG_WARNING("in FillRecParametersTP. WARNING: m_trackToVertexIPEstimator is NULL");
1730  return StatusCode::FAILURE;
1731  }
1732 
1733  if (m_doIP && vertex != nullptr && m_trackToVertexIPEstimator){
1734  std::unique_ptr<Trk::ImpactParametersAndSigma> iPandSigma(nullptr);
1735  ATH_MSG_DEBUG("-- using the trackToVertexIPEstimator --");
1736 
1737  //Calling the estimate(trackp,newtrackp,vertex,doRemoval)
1738  //The first track is used to unbias the vertex, the second to get the extrapolation
1739  if (!m_skipMS) iPandSigma = m_trackToVertexIPEstimator->estimate(trackp_for_unbias, trackp, vertex, m_doRemoval);
1740  else iPandSigma = m_trackToVertexIPEstimator->estimate(trackp, vertex);
1741  ATH_MSG_DEBUG("return from the trackToVertexIPEstimator->estimate()");
1742 
1743  if( !iPandSigma ){
1744  ATH_MSG_WARNING ("FillRecParametersTP::trackToVertexIPEstimator failed !");
1745  return StatusCode::FAILURE;
1746  }
1747  else{
1748  ATH_MSG_DEBUG("FillRecParametersTP::trackToVertexIPEstimator success !");
1749  PVd0 = iPandSigma->IPd0;
1750  PVd0res = iPandSigma->PVsigmad0;
1751  d0res = iPandSigma->sigmad0;
1752  PVz0 = iPandSigma->IPz0;
1753  PVz0res = iPandSigma->PVsigmaz0;
1754  z0res = iPandSigma->sigmaz0;
1755  }
1756  }
1757 
1758  if (charge == 1) {
1759  m_positive_px = px;
1760  m_positive_py = py;
1761  m_positive_pt = pt;
1762  m_positive_pz = pz;
1763  m_positive_phi= phi;
1764  m_positive_eta= eta;
1765  m_positive_z0 = z0;
1766  m_positive_z0_err = z0res;
1767  m_positive_d0 = d0;
1768  m_positive_d0_err = d0res;
1769  m_positive_sigma_pt = sigma_pt;
1770  m_positive_qoverp = qoverp;
1771  m_positive_sigma_qoverp = sigma_qOverP;
1772  if(m_doIP){
1773  m_positive_z0_PV = PVz0;
1774  m_positive_d0_PV = PVd0;
1775  m_positive_z0_PVerr = PVz0res;
1776  m_positive_d0_PVerr = PVd0res;
1777  }
1778  ATH_MSG_DEBUG("(Filled charge == 1 ) (reco)-> px : "<< px <<" py: "<<py <<" pt: "<<pt <<" pz: "<<pz
1779  <<" d0: "<<m_positive_d0 << " d0res : "<< d0res << " PVd0res : "<< PVd0res <<" z0: "<< m_positive_z0 << " z0res : " << z0res << " PVz0res : "<< PVz0res );
1780 
1781  } else if (charge == -1) {
1782  m_negative_px = px;
1783  m_negative_py = py;
1784  m_negative_pt = pt;
1785  m_negative_pz = pz;
1786  m_negative_phi= phi;
1787  m_negative_eta= eta;
1788  m_negative_z0 = z0;
1789  m_negative_z0_err = z0res;
1790  m_negative_d0 = d0;
1791  m_negative_d0_err = d0res;
1792  m_negative_sigma_pt = sigma_pt;
1793  m_negative_qoverp = qoverp;
1794  m_negative_sigma_qoverp = sigma_qOverP;
1795  if(m_doIP){
1796  m_negative_z0_PV = PVz0;
1797  m_negative_d0_PV = PVd0;
1798  m_negative_z0_PVerr = PVz0res;
1799  m_negative_d0_PVerr = PVd0res;
1800  }
1801  ATH_MSG_DEBUG("(Filled charge == -1 ) (reco)-> px : "<< px <<" py: "<< py <<" pt: " << pt <<" pz: "<<pz
1802  <<" d0: "<<m_negative_d0 << " d0res : "<< d0res << " PVd0res : "<< PVd0res <<" z0: "<< m_negative_z0 << " z0res : " << z0res << " PVz0res : "<< PVz0res );
1803  }
1804 
1805  return StatusCode::SUCCESS;
1806 }

◆ FillTruthParameters()

StatusCode IDPerfMonZmumu::FillTruthParameters ( const xAOD::TrackParticle *  track)
private

Definition at line 2074 of file IDPerfMonZmumu.cxx.

2075 {
2076 
2077  if (!trackParticle ){//|| !trackParticle->vertex()){
2078  ATH_MSG_WARNING("-- FillTruthParameters -- Empty Trackparticle. Skipping.");
2079  return StatusCode::FAILURE;
2080  }
2081 
2082  static const SG::ConstAccessor<float> truthMatchProbabilityAcc("truthMatchProbability");
2083  float result = truthMatchProbabilityAcc.withDefault(*trackParticle,
2084  std::numeric_limits<float>::quiet_NaN());
2085  ATH_MSG_DEBUG(" -- FillTruthParameters -- TruthMatchProbablity of trackpartile : > " << result);
2086 
2087 
2088  const xAOD::TruthParticle* particle = getTruthParticle( *trackParticle );
2089  double charge = 0;
2090  if (!particle) {
2091  ATH_MSG_DEBUG(" -- FillTruthParameters -- Failure while retrieving the truth particle. Returning FAILURE.");
2092  return StatusCode::FAILURE;
2093  }
2094 
2095  if ( particle->pdgId() == 13) charge = -1.; // muon-
2096  if ( particle->pdgId() == -13) charge = 1.; // muon+
2097  if ( particle->isNeutral() ) {
2098  ATH_MSG_DEBUG(" -- FillTruthParameters -- reco muon associated to a truth neutral!! Returning FAILURE.");
2099  return StatusCode::FAILURE;
2100  }
2101  if ( charge == 0 ) {
2102  ATH_MSG_DEBUG(" -- FillTruthParameters -- reco muon associated to a non true muon!! Returning FAILURE.");
2103  return StatusCode::FAILURE;
2104  }
2105 
2106  const Amg::Vector3D momentum(particle->px(), particle->py(), particle->pz());
2107  const xAOD::TruthVertex * ptruthVertex(0);
2108  ptruthVertex=particle->prodVtx();
2109  if (!ptruthVertex){
2110  ATH_MSG_DEBUG("A production vertex pointer was retrieved, but it is NULL");
2111  return StatusCode::FAILURE;
2112  }
2113 
2114 
2115  if (particle->parent(0) != nullptr) {
2116  static const SG::ConstAccessor<int> truthTypeAcc("truthType");
2117  static const SG::ConstAccessor<int> truthOriginAcc("truthOrigin");
2118  if (truthTypeAcc.isAvailable(*particle)) {
2119  ATH_MSG_DEBUG(" -- FillTruthParameters -- truth particle is good. pdg: " << particle->pdgId()
2120  << " type: " << particle->type()
2121  << " nparents " << particle->nParents()
2122  << " parent->pdg: " << particle->parent(0)->pdgId()
2123  << " truthType: " << truthTypeAcc(*particle)
2124  << " truthOrigin: " << truthOriginAcc(*particle)
2125  );
2126 
2127  }
2128  else {
2129  ATH_MSG_DEBUG(" -- FillTruthParameters -- truth particle is good. pdg: " << particle->pdgId()
2130  << " type: " << particle->type()
2131  << " nparents " << particle->nParents()
2132  << " parent->pdg: " << particle->parent(0)->pdgId()
2133  << " truthType & truthOrigin: " << " NOT AVAILABLE "
2134  );
2135  }
2136  }
2137 
2138  const auto xPos=ptruthVertex->x();
2139  const auto yPos=ptruthVertex->y();
2140  const auto z_truth=ptruthVertex->z();
2141 
2142  const Amg::Vector3D position(xPos, yPos, z_truth);
2143  const Trk::CurvilinearParameters cParameters(position, momentum, charge);
2144 
2145  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandleTruth { m_beamSpotKey };
2146  Trk::PerigeeSurface persf( beamSpotHandleTruth->beamPos() );
2147 
2148  const EventContext& ctx = Gaudi::Hive::currentContext();
2149  std::unique_ptr<const Trk::TrackParameters> tP = m_extrapolator->extrapolate(ctx, cParameters,persf, Trk::anyDirection, false);
2150 
2151  double px = 0;
2152  double py = 0;
2153  double pt = 0;
2154  double pz = 0;
2155  double phi= 0;
2156  double eta= 0;
2157  double d0 = 0;
2158  double d0res = 0;
2159  double PVd0res = 0;
2160  double z0 = 0;
2161  double z0res = 0;
2162  double PVz0res = 0;
2163 
2164  double d0recoPos = m_positive_d0;
2165  double z0recoPos = m_positive_z0;
2166  double d0recoNeg = m_negative_d0;
2167  double z0recoNeg = m_negative_z0;
2168 
2169  ATH_MSG_DEBUG("reco IPs (pos): > d0 : "<<d0recoPos << " z0: " << z0recoPos << " trackp z0 : " << trackParticle->z0() << " trackp d0 : " << trackParticle->d0());
2170  ATH_MSG_DEBUG("reco IPs (neg): > d0 : "<<d0recoNeg << " z0: " << z0recoNeg << " trackp z0 : " << trackParticle->z0() <<" trackp d0 : " << trackParticle->d0() );
2171 
2172  double qOverP_truth = 0.;
2173  if (tP){
2174  qOverP_truth = tP->parameters()[Trk::qOverP];
2175  if( qOverP_truth ){
2176 
2177  px = tP->momentum().x();
2178  py = tP->momentum().y();
2179  pt = tP->pT();
2180  pz = tP->momentum().z();
2181  phi= tP->parameters()[Trk::phi];
2182  eta= tP->eta();
2183  d0 = tP->parameters()[Trk::d0];
2184  z0 = tP->parameters()[Trk::z0];
2185 
2186  ATH_MSG_DEBUG("cand perig HEP particle (truth) px : "<< tP->momentum().x());
2187  ATH_MSG_DEBUG("cand perig HEP particle (truth) py : "<< tP->momentum().y());
2188  ATH_MSG_DEBUG("cand perig HEP particle (truth) pz : "<< tP->momentum().z());
2189  ATH_MSG_DEBUG("cand perig HEP particle (truth) d0 : "<< tP->parameters()[Trk::d0]);
2190  ATH_MSG_DEBUG("cand perig HEP particle (truth) z0 : "<< tP->parameters()[Trk::z0]);
2191 
2192  }
2193  }
2194 
2195 
2196  if (charge == 1) {
2197  m_positive_px = px;
2198  m_positive_py = py;
2199  m_positive_pt = pt;
2200  m_positive_pz = pz;
2201  m_positive_phi= phi;
2202  m_positive_eta= eta;
2203  m_positive_z0 = z0recoPos -z0;
2204  m_positive_z0_err = z0res;
2205  m_positive_z0_PVerr = PVz0res;
2206  m_positive_d0 = d0recoPos -d0;
2207  m_positive_d0_err = d0res;
2208  m_positive_d0_PVerr = PVd0res;
2209  m_positive_qoverp = qOverP_truth;
2210 
2211  bool parentfound = false;
2212  if (particle->nParents()>0) {
2213  if (particle->parent(0) != nullptr) {
2214  m_positive_parent = particle->parent(0)->pdgId();
2215  parentfound = true;
2216  }
2217  }
2218  if (!parentfound) m_positive_parent = 0;
2219 
2220  ATH_MSG_DEBUG(" -- FillTruthParameters -- charge = 1 (truth)-> px : "<< m_positive_px
2221  <<" py: "<<m_positive_py
2222  <<" pz: "<<m_positive_pz
2223  <<" d0: "<<m_positive_d0
2224  <<" z0: "<< m_positive_z0
2225  <<" qoverp: " << m_positive_qoverp
2226  << " parent: " << m_positive_parent);
2227 
2228  } else if (charge == -1) {
2229  m_negative_px = px;
2230  m_negative_py = py;
2231  m_negative_pt = pt;
2232  m_negative_pz = pz;
2233  m_negative_phi= phi;
2234  m_negative_eta= eta;
2235  m_negative_z0 = z0recoNeg-z0;
2236  m_negative_z0_err = z0res;
2237  m_negative_z0_PVerr = PVz0res;
2238  m_negative_d0 = d0recoNeg-d0;
2239  m_negative_d0_err = d0res;
2240  m_negative_d0_PVerr = PVd0res;
2241  m_negative_qoverp = qOverP_truth;
2242 
2243  bool parentfound = false;
2244  if (particle->nParents()>0) {
2245  if (particle->parent(0) != nullptr) {
2246  m_negative_parent = particle->parent(0)->pdgId();
2247  parentfound = true;
2248  }
2249  }
2250  if (!parentfound) m_negative_parent = 0;
2251 
2252  ATH_MSG_DEBUG(" -- FillTruthParameters-- charge = -1 (truth)-> px : "<< m_negative_px
2253  << " py: "<<m_negative_py
2254  << " pz: "<<m_negative_pz
2255  << " d0: "<<m_negative_d0
2256  << " z0: "<< m_negative_z0
2257  <<" qoverp: " << m_negative_qoverp
2258  << " parent:" << m_negative_parent);
2259  }
2260  return StatusCode::SUCCESS;
2261 }

◆ finalize()

StatusCode IDPerfMonZmumu::finalize ( )
virtual

Definition at line 2285 of file IDPerfMonZmumu.cxx.

2286 {
2287  m_xZmm.finalize();
2288  return StatusCode::SUCCESS;
2289 }

◆ GetDiMuonVertex()

const xAOD::Vertex * IDPerfMonZmumu::GetDiMuonVertex ( const xAOD::TrackParticle *  muon1,
const xAOD::TrackParticle *  muon2 
)
private

Definition at line 2352 of file IDPerfMonZmumu.cxx.

2352  {
2353 
2354  const xAOD::VertexContainer* vxContainer(0);
2355  const xAOD::Vertex* myVtx(0);
2356  vxContainer = PerfMonServices::getContainer<xAOD::VertexContainer> (PerfMonServices::VTX_COLLECTION);
2357  if (!vxContainer) {
2358  return myVtx;
2359  }
2360 
2361  for (int ivtx=0; ivtx< (int) vxContainer->size();ivtx++) {
2362  myVtx = (*vxContainer)[ivtx];
2363  if ((myVtx->vertexType() == xAOD::VxType::PriVtx)) {
2364  if (m_Trk2VtxAssociationTool->isCompatible(*muon1,*myVtx) && (m_Trk2VtxAssociationTool->isCompatible(*muon2,*myVtx)))
2365  return myVtx;
2366  }
2367  }
2368  return myVtx;
2369 }

◆ GetMuonQualityValue()

int IDPerfMonZmumu::GetMuonQualityValue ( std::string  qualityname)
private

◆ getTruthParticle()

const xAOD::TruthParticle * IDPerfMonZmumu::getTruthParticle ( const xAOD::IParticle &  p)
private

A convenience type declaration

A static accessor for the information

Definition at line 2265 of file IDPerfMonZmumu.cxx.

2265  {
2267  typedef ElementLink< xAOD::TruthParticleContainer > Link_t;
2269  static const SG::ConstAccessor< Link_t > acc( "truthParticleLink" );
2270  // Check if such a link exists on the object:
2271  if( ! acc.isAvailable( p ) ) {
2272  return nullptr;
2273  }
2274  // Get the link:
2275  const Link_t& link = acc( p );
2276  // Check if the link is valid:
2277  if( ! link.isValid() ) {
2278  return nullptr;
2279  }
2280  // Everything has passed, let's return the pointer:
2281  return *link;
2282 }

◆ initialize()

StatusCode IDPerfMonZmumu::initialize ( )
virtual

Definition at line 170 of file IDPerfMonZmumu.cxx.

171 {
172  ATH_MSG_DEBUG ("** IDPerfMonZmumu::Initialize ** START **");
173  // Setup the services
174  ISvcLocator* pxServiceLocator = serviceLocator();
175  if ( pxServiceLocator != nullptr ) {
176  StatusCode xSC = PerfMonServices::InitialiseServices( pxServiceLocator );
177  if ( xSC == StatusCode::FAILURE ) {
178  ATH_MSG_FATAL("Problem Initializing PerfMonServices");
179  return StatusCode::FAILURE;
180  }
181  else {
182  ATH_MSG_DEBUG("PerfMonServices::InitialiseServices( pxServiceLocator ); SUCCESS ");
183  }
184  }
185 
186  // Retrieve Track fitter and track to vertex
187  if (m_doRefit) { // only if track refit is requested
188  if (m_TrackRefitter1.retrieve().isSuccess()) {
189  ATH_MSG_INFO("Retrieved tool m_TrackRefitter1: " << m_TrackRefitter1 << " SUCCESS ");
190  }
191  else {
192  ATH_MSG_FATAL("Unable to retrieve m_TrackRefitter1 " << m_TrackRefitter1 << " FAILURE ");
193  return StatusCode::FAILURE;
194  }
195 
196  // Retrieve the second fitter
197  if (m_TrackRefitter2.retrieve().isSuccess()) {
198  ATH_MSG_INFO("Retrieved tool m_TrackRefitter2: " << m_TrackRefitter2 << " SUCCESS ");
199  }
200  else {
201  ATH_MSG_FATAL("Unable to retrieve m_TrackRefitter2 " << m_TrackRefitter2 << " FAILURE ");
202  return StatusCode::FAILURE;
203  }
204 
205  if (m_trackToVertexTool.retrieve().isSuccess()) {
206  ATH_MSG_INFO("Retrieved tool m_trackToVertexTool " << m_trackToVertexTool << " SUCCESS ");
207  }
208  else {
209  ATH_MSG_FATAL("Unable to retrieve m_trackToVertexTool " << m_trackToVertexTool << " FAILURE ");
210  return StatusCode::FAILURE;
211  }
212  }
213 
214  if(m_useTrackSelectionTool){
215  // ATH_CHECK( m_selTool.retrieve() );
216  if (m_selTool.retrieve().isSuccess()){
217  ATH_MSG_INFO("Retrieved tool (track selection tool) m_selTool " << m_selTool << " SUCCESS ");
218  }
219  else {
220  ATH_MSG_FATAL("Unable to retrieve (track selection tool) m_selTool " << m_selTool << " FAILURE ");
221  return StatusCode::FAILURE;
222  }
223  }
224 
225  // initializing the eventInfo "accessor"
226  ATH_CHECK( m_EventInfoKey.initialize() );
227 
228  if (m_doIP) {
229  ATH_MSG_DEBUG("Retrieving tool (trackToVertexIPEstimator)");
230  ATH_CHECK (m_trackToVertexIPEstimator.retrieve());
231  }
232 
233 
234  ATH_CHECK (m_EventInfoKey.initialize()); // initializing the eventInfo "accessor"
235 
236  if (m_isMC) ATH_CHECK (m_extrapolator.retrieve()); // this is only used for the truth particles
237 
238  ATH_CHECK (m_vertexKey.initialize());
239 
240  ATH_CHECK (m_trackContainerName.initialize());
241 
242  ATH_MSG_INFO(" -- IDPerfMonZmumu::initialize() -- m_vertexKey: " << m_vertexKey);
243 
244  ATH_MSG_INFO(" -- IDPerfMonZmumu::initialize() -- init m_beamSpotKey ");
245  ATH_CHECK(m_beamSpotKey.initialize());
246 
247  // START new place for initilization of params
248  m_xZmm.setContainer (PerfMonServices::MUON_COLLECTION);
249  m_xZmm.doIsoSelection (m_doIsoSelection);
250  m_xZmm.doIPSelection (m_doIPSelection);
251  m_xZmm.doMCPSelection (m_doMCPSelection);
252  m_xZmm.SetMassWindowLow (m_MassWindowLow);
253  m_xZmm.SetMassWindowHigh (m_MassWindowHigh);
254  m_xZmm.SetLeadingMuonPtCut(m_LeadingMuonPtCut);
255  m_xZmm.SetSecondMuonPtCut (m_SecondMuonPtCut);
256  m_xZmm.SetOpeningAngleCut (m_OpeningAngleCut);
257  m_xZmm.SetZ0GapCut (m_Z0GapCut);
258  m_xZmm.setDebugMode (m_doDebug);
259  m_xZmm.SetMuonQuality (m_MuonQualityName);
260  m_xZmm.SetSkipMSCheck (m_skipMS);
261  m_xZmm.SetMinLumiBlock (m_minGoodLumiBlock);
262  m_xZmm.SetMaxLumiBlock (m_maxGoodLumiBlock);
263 
264  if (m_useCustomMuonSelector) {
265  m_xZmm.SetMuonSelectionTool (m_muonSelector);
266  }
267  // END new place for initialization of params
268 
269  if (m_doFourMuAnalysis) {
270  m_4mu.Init();
271  m_4mu.setDebugMode(true);
272  if (m_useCustomMuonSelector) m_4mu.SetMuonSelectionTool (m_muonSelector);
273  ATH_MSG_DEBUG(" IDPerfMonZmumu FourMuonAnalysis initialization completed " << m_Trk2VtxAssociationTool);
274  }
275 
276  // m_Trk2VtxAssociationTool = std::make_unique<CP::TrackVertexAssociationTool>("Loose");
277  if ( m_Trk2VtxAssociationTool.retrieve().isSuccess() ) {
278  ATH_MSG_DEBUG(" IDPerfMonZmumu Success retrieving tool " << m_Trk2VtxAssociationTool);
279  }
280  else { // is Failure
281  ATH_MSG_FATAL("IDPerfMonZmumu Failed to retrieve tool m_Trk2VtxAssociationTool " << m_Trk2VtxAssociationTool);
282  return StatusCode::FAILURE;
283  }
284 
285  ATH_CHECK ( this->bookTrees() );
286 
287  if (m_UseTrigger) { // load trigger decission and matching under user request
288  if (m_triggerDecision.retrieve().isFailure()) {
289  ATH_MSG_FATAL("Unable to retrieve " << m_triggerDecision << " turn it off");
290  return StatusCode::FAILURE;
291  }
292  else {
293  ATH_MSG_DEBUG("retrieved tool: " << m_triggerDecision );
294  }
295 
296  if(m_triggerMatching.retrieve().isFailure()) {
297  ATH_MSG_FATAL("Unable to retrieve " << m_triggerMatching << " turn it off");
298  return StatusCode::FAILURE;
299  }
300  else {
301  ATH_MSG_INFO("retrieved tool: " << m_triggerDecision );
302  }
303  }
304 
305  ATH_MSG_DEBUG("** IDPerfMonZmumu::Initialize ** Completed **");
306  return StatusCode::SUCCESS;
307 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ RegisterHistograms()

void IDPerfMonZmumu::RegisterHistograms ( )
private

Definition at line 942 of file IDPerfMonZmumu.cxx.

943 {
944  return;
945 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ ResetCommonNtupleVectors()

void IDPerfMonZmumu::ResetCommonNtupleVectors ( )
private

Definition at line 2372 of file IDPerfMonZmumu.cxx.

2373 {
2374  m_IDTrack_pt.clear();
2375  m_CBTrack_pt.clear();
2376  m_Refit1_pt.clear();
2377  m_Refit2_pt.clear();
2378  m_Truth_pt.clear();
2379 
2380  m_IDTrack_eta.clear();
2381  m_CBTrack_eta.clear();
2382  m_Refit1_eta.clear();
2383  m_Refit2_eta.clear();
2384  m_Truth_eta.clear();
2385 
2386  m_IDTrack_phi.clear();
2387  m_CBTrack_phi.clear();
2388  m_Refit1_phi.clear();
2389  m_Refit2_phi.clear();
2390  m_Truth_phi.clear();
2391 
2392  m_IDTrack_d0.clear();
2393  m_CBTrack_d0.clear();
2394  m_Refit1_d0.clear();
2395  m_Refit2_d0.clear();
2396  m_Truth_d0.clear();
2397 
2398  m_IDTrack_z0.clear();
2399  m_CBTrack_z0.clear();
2400  m_Refit1_z0.clear();
2401  m_Refit2_z0.clear();
2402  m_Truth_z0.clear();
2403 
2404  m_IDTrack_qoverp.clear();
2405  m_CBTrack_qoverp.clear();
2406  m_Refit1_qoverp.clear();
2407  m_Refit2_qoverp.clear();
2408  m_Truth_qoverp.clear();
2409 
2410  m_Truth_parent.clear();
2411 
2412  m_IDTrack_sigma_pt.clear();
2413  m_CBTrack_sigma_pt.clear();
2414  m_Refit1_sigma_pt.clear();
2415  m_Refit2_sigma_pt.clear();
2416 
2417  m_IDTrack_sigma_d0.clear();
2418  m_CBTrack_sigma_d0.clear();
2419  m_Refit1_sigma_d0.clear();
2420  m_Refit2_sigma_d0.clear();
2421 
2422  m_IDTrack_sigma_z0.clear();
2423  m_CBTrack_sigma_z0.clear();
2424  m_Refit1_sigma_z0.clear();
2425  m_Refit2_sigma_z0.clear();
2426 
2427  m_IDTrack_sigma_qoverp.clear();
2428  m_CBTrack_sigma_qoverp.clear();
2429  m_Refit1_sigma_qoverp.clear();
2430  m_Refit2_sigma_qoverp.clear();
2431 
2432  m_nBLhits.clear();
2433  m_nPIXhits.clear();
2434  m_nSCThits.clear();
2435  m_nTRThits.clear();
2436 
2437  return;
2438 }

◆ RunFourLeptonAnalysis()

StatusCode IDPerfMonZmumu::RunFourLeptonAnalysis ( )
private

Definition at line 2532 of file IDPerfMonZmumu.cxx.

2533 {
2534  StatusCode thisStatus = StatusCode::SUCCESS;
2535 
2536  if (m_doFourMuAnalysis) {
2537  ATH_MSG_DEBUG ("** RunFourLeptonAnalysis ** START ** run: " << m_runNumber << " event: " << m_evtNumber << " lumiblock:" << m_lumi_block);
2538 
2539  // Four lepton event
2540  m_4mu.setContainer(PerfMonServices::MUON_COLLECTION);
2541  m_4mu.doIsoSelection (m_doIsoSelection);
2542  m_4mu.doIPSelection (m_doIPSelection);
2543  m_4mu.doMCPSelection (m_doMCPSelection);
2544  m_4mu.SetMassWindowLow (m_MassWindowLow);
2545  m_4mu.SetMassWindowHigh (m_MassWindowHigh);
2546  m_4mu.SetLeadingMuonPtCut(m_LeadingMuonPtCut);
2547  m_4mu.SetSecondMuonPtCut (m_SecondMuonPtCut);
2548  m_4mu.SetOpeningAngleCut (m_OpeningAngleCut);
2549  m_4mu.SetZ0GapCut (m_Z0GapCut);
2550  m_4mu.setDebugMode (m_doDebug);
2551 
2552  // This is a report of the number of true electrons in the event
2553  if (false) {
2554  const xAOD::TruthParticleContainer* electronTruth = evtStore()->retrieve< const xAOD::TruthParticleContainer >( "egammaTruthParticles" );
2555  if( electronTruth) {
2556  ATH_MSG_DEBUG ( "retrieving electron Truth container with key: \"egammaTruthParticles\" SUCCESS ");
2557  // Check that the auxiliary store association was made successfully:
2558  if( electronTruth->hasStore() ) {
2559  ATH_MSG_DEBUG ( "Size of Truth gamma-electrons: " << electronTruth->size() );
2560  auto tr_itr = electronTruth->begin();
2561  auto tr_end = electronTruth->end();
2562  int electronCount = 0;
2563  for( int i = 0; tr_itr != tr_end; ++tr_itr, ++i ) {
2564  ATH_MSG_DEBUG( "Truth : Investigating truth electron #" << i << " pdgID= " << ( *tr_itr )->pdgId());
2565  if (fabs(( *tr_itr )->pdgId()) == 11) {
2566  if (( *tr_itr )->pt() > 10000 && fabs(( *tr_itr )->eta()) < 2.47) {
2567  ATH_MSG_INFO( " central electron found --> pt: " << ( *tr_itr )->charge()*( *tr_itr )->pt() << " eta " <<( *tr_itr )->eta() );
2568  electronCount++;
2569  }
2570  }
2571  }
2572  ATH_MSG_INFO( "#central electrons: " << electronCount );
2573  }
2574  else {
2575  ATH_MSG_WARNING ( "electronTruth container has no Store !!! FAILURE");
2576  }
2577  }
2578  else {
2579  ATH_MSG_WARNING ( "retrieve electron Truth container with key: \"egammaTruthParticles\" FAILURE");
2580  }
2581  }
2582 
2583  if (m_doDebug) std::cout << " ** RunFourLeptonAnalysis ** calling m_4mu.Reco() .... " << std::endl;
2584  bool statusOf4LeptReco = m_4mu.Reco();
2585 
2586  // print message
2587  if(statusOf4LeptReco) {
2588  thisStatus = StatusCode::SUCCESS;
2589  ATH_MSG_INFO ("4-lepton reconstruction SUCCESS. # accepted events " << m_4mu.getAcceptedEvents() << " Invariant mass = " << m_4mu.GetInvMass() << " GeV ");
2590  if (m_doDebug) std::cout << " ** RunFourLeptonAnalysis ** 4-lepton reconstruction SUCCESS. # accepted events " << m_4mu.getAcceptedEvents() << " Invariant mass = " << m_4mu.GetInvMass() << " GeV " << std::endl;
2591  }
2592  else {
2593  thisStatus = StatusCode::FAILURE;
2594  ATH_MSG_DEBUG ("4-lepton reconstruction FAILURE. m_4mu.Reco() returned FALSE --> event failed selection");
2595  if (m_doDebug) std::cout << " ** RunFourLeptonAnalysis ** 4-lepton reconstruction FAILURE. m_4mu.Reco() returned FALSE --> event failed selection" << std::endl;
2596  }
2597 
2598  if(statusOf4LeptReco) {
2599  if ( m_4mu.EventPassed() ) {
2600 
2601  this->Clear4MuNtupleVariables();
2602 
2603  const xAOD::TrackParticle* muon1_pos = m_4mu.getIDTrack(m_4mu.getPosMuon(1));
2604  const xAOD::TrackParticle* muon2_pos = m_4mu.getIDTrack(m_4mu.getPosMuon(2));
2605  const xAOD::TrackParticle* muon1_neg = m_4mu.getIDTrack(m_4mu.getNegMuon(1));
2606  const xAOD::TrackParticle* muon2_neg = m_4mu.getIDTrack(m_4mu.getNegMuon(2));
2607 
2608  // muons
2609  if (muon1_pos) {
2610  m_positive_px = muon1_pos->p4().Px();
2611  m_positive_py = muon1_pos->p4().Py();
2612  m_positive_pz = muon1_pos->p4().Pz();
2613  m_positive_d0 = muon1_pos->d0();
2614  m_positive_z0 = muon1_pos->z0();
2615  // m_positive_d0_err = muon1_pos->definingParametersCovMatrix()(0,0);
2616  m_positive_d0_err = muon1_pos->definingParametersCovMatrixVec()[0];
2617  m_positive_z0_err = muon1_pos->definingParametersCovMatrix()(1,1);
2618  }
2619  if (muon1_neg) {
2620  m_negative_px = muon1_neg->p4().Px();
2621  m_negative_py = muon1_neg->p4().Py();
2622  m_negative_pz = muon1_neg->p4().Pz();
2623  m_negative_d0 = muon1_neg->d0();
2624  m_negative_z0 = muon1_neg->z0();
2625  m_negative_d0_err = muon1_neg->definingParametersCovMatrix()(0,0);
2626  m_negative_z0_err = muon1_neg->definingParametersCovMatrix()(1,1);
2627  }
2628  if (muon2_pos) {
2629  m_positive_2_px = muon2_pos->p4().Px();
2630  m_positive_2_py = muon2_pos->p4().Py();
2631  m_positive_2_pz = muon2_pos->p4().Pz();
2632  m_positive_2_d0 = muon2_pos->d0();
2633  m_positive_2_z0 = muon2_pos->z0();
2634  m_positive_2_d0_err = muon2_pos->definingParametersCovMatrix()(0,0);
2635  m_positive_2_z0_err = muon2_pos->definingParametersCovMatrix()(1,1);
2636  }
2637  if (muon2_neg) {
2638  m_negative_2_px = muon2_neg->p4().Px();
2639  m_negative_2_py = muon2_neg->p4().Py();
2640  m_negative_2_pz = muon2_neg->p4().Pz();
2641  m_negative_2_d0 = muon2_neg->d0();
2642  m_negative_2_z0 = muon2_neg->z0();
2643  m_negative_2_d0_err = muon2_neg->definingParametersCovMatrix()(0,0);
2644  m_negative_2_z0_err = muon2_neg->definingParametersCovMatrix()(1,1);
2645  }
2646 
2647  // electrons
2648  const xAOD::TrackParticle* elec1_neg = m_4mu.getELTrack(0);
2649  const xAOD::TrackParticle* elec2_neg = m_4mu.getELTrack(1);
2650  const xAOD::TrackParticle* elec1_pos = m_4mu.getELTrack(2);
2651  const xAOD::TrackParticle* elec2_pos = m_4mu.getELTrack(3);
2652  if (elec1_neg) {
2653  m_el_negative1_px = elec1_neg->p4().Px();
2654  m_el_negative1_py = elec1_neg->p4().Py();
2655  m_el_negative1_pz = elec1_neg->p4().Pz();
2656  m_el_negative1_d0 = elec1_neg->d0();
2657  m_el_negative1_z0 = elec1_neg->z0();
2658  m_el_negative1_d0_err = elec1_neg->definingParametersCovMatrix()(0,0);
2659  m_el_negative1_z0_err = elec1_neg->definingParametersCovMatrix()(1,1);
2660  }
2661  if (elec2_neg) {
2662  m_el_negative2_px = elec2_neg->p4().Px();
2663  m_el_negative2_py = elec2_neg->p4().Py();
2664  m_el_negative2_pz = elec2_neg->p4().Pz();
2665  m_el_negative2_d0 = elec2_neg->d0();
2666  m_el_negative2_z0 = elec2_neg->z0();
2667  m_el_negative2_d0_err = elec2_neg->definingParametersCovMatrix()(0,0);
2668  m_el_negative2_z0_err = elec2_neg->definingParametersCovMatrix()(1,1);
2669  }
2670  if (elec1_pos) {
2671  m_el_positive1_px = elec1_pos->p4().Px();
2672  m_el_positive1_py = elec1_pos->p4().Py();
2673  m_el_positive1_pz = elec1_pos->p4().Pz();
2674  m_el_positive1_d0 = elec1_pos->d0();
2675  m_el_positive1_z0 = elec1_pos->z0();
2676  m_el_positive1_d0_err = elec1_pos->definingParametersCovMatrix()(0,0);
2677  m_el_positive1_z0_err = elec1_pos->definingParametersCovMatrix()(1,1);
2678  }
2679  if (elec2_pos) {
2680  m_el_positive2_px = elec2_pos->p4().Px();
2681  m_el_positive2_py = elec2_pos->p4().Py();
2682  m_el_positive2_pz = elec2_pos->p4().Pz();
2683  m_el_positive2_d0 = elec2_pos->d0();
2684  m_el_positive2_z0 = elec2_pos->z0();
2685  m_el_positive2_d0_err = elec2_pos->definingParametersCovMatrix()(0,0);
2686  m_el_positive2_z0_err = elec2_pos->definingParametersCovMatrix()(1,1);
2687  }
2688 
2689  // other quantities
2690  m_nVertex = m_4mu.GetNVertex ();
2691  m_negative_1_vtx = m_4mu.GetVertexMuNeg1();
2692  m_negative_2_vtx = m_4mu.GetVertexMuNeg2();
2693  m_positive_1_vtx = m_4mu.GetVertexMuPos1();
2694  m_positive_2_vtx = m_4mu.GetVertexMuPos2();
2695 
2696  m_el_negative1_vtx = m_4mu.GetVertexElec(0);
2697  m_el_negative2_vtx = m_4mu.GetVertexElec(1);
2698  m_el_positive1_vtx = m_4mu.GetVertexElec(2);
2699  m_el_positive2_vtx = m_4mu.GetVertexElec(3);
2700 
2701  m_pv_x = 0; m_pv_y = 0; m_pv_z = 0;
2702 
2703  m_4mu_minv = m_4mu.GetInvMass();
2704 
2705  // Obtain MET
2706  std::string metName = "MET_Reference_AntiKt4LCTopo";
2707  std::string metRefFinalName = "FinalClus";
2708  const xAOD::MissingETContainer* final_met = nullptr;
2709 
2710  m_met = -1; // default value
2711  m_metphi = -1;
2712 
2713  if (!evtStore()->contains<xAOD::MissingETContainer>(metName)) {
2714  ATH_MSG_WARNING ( "No Collection with name " << metName << " found in StoreGate");
2715  // return StatusCode::SUCCESS;
2716  }
2717  else {
2718  StatusCode sc = evtStore()->retrieve(final_met, metName);
2719  if (sc.isFailure()) {
2720  ATH_MSG_DEBUG ( "Could not retrieve Collection " << metName << " from StoreGate");
2721  // return StatusCode::SUCCESS;
2722  }
2723  }
2724  const xAOD::MissingET *met = nullptr;
2725  if (final_met) met = (*final_met)[metRefFinalName];
2726  if (met) { // load MET values
2727  m_met = met->met();
2728  m_metphi = met->phi();
2729  }
2730  ATH_MSG_DEBUG (" Zmumu event with MET = " << m_met);
2731 
2732  ATH_MSG_INFO (" -- IDPerfMonZmumu::execute -- Accepted event " << m_4mu.getAcceptedEvents() << " with m_4mu.GetInvMass= " << m_4mu_minv);
2733  ATH_MSG_DEBUG ("**** Filling m_FourMuTree ntuple " << m_FourMuTree->GetName() << " entry " << m_FourMuTree->GetEntries()
2734  << " for run: " << m_runNumber
2735  << " event: " << m_evtNumber
2736  << " Lumiblock: " << m_lumi_block
2737  << " Invariant mass = " << m_4mu_minv << " GeV ");
2738  if (muon1_pos != nullptr) ATH_MSG_DEBUG("mu1+ --> pxyz " << muon1_pos->p4().Px()
2739  << ", " << muon1_pos->p4().Py()
2740  << ", " << muon1_pos->p4().Pz()
2741  << " pt: " << muon1_pos->pt()
2742  << " d0: " << muon1_pos->d0()
2743  << " z0: " << muon1_pos->z0()
2744  << " d0unc: " << muon1_pos->definingParametersCovMatrixVec()[0]
2745  );
2746  if (muon1_neg != nullptr) ATH_MSG_DEBUG("mu1- --> pxyz " << muon1_neg->p4().Px()
2747  << ", " << muon1_neg->p4().Py()
2748  << ", " << muon1_neg->p4().Pz()
2749  << " pt: " << muon1_neg->pt()
2750  << " d0: " << muon1_neg->d0()
2751  << " z0: " << muon1_neg->z0()
2752  << " d0unc: " << muon1_neg->definingParametersCovMatrixVec()[0]
2753  );
2754  if (elec1_pos != nullptr) ATH_MSG_DEBUG("el1+ --> pxyz " << elec1_pos->p4().Px()
2755  << ", " << elec1_pos->p4().Py()
2756  << ", " << elec1_pos->p4().Pz()
2757  << " pt: " << elec1_pos->pt()
2758  << " d0: " << elec1_pos->d0()
2759  << " z0: " << elec1_pos->z0()
2760  << " d0unc: " << elec1_pos->definingParametersCovMatrixVec()[0]
2761  );
2762  // ntuple variables have been filled in FillRecParametersTP
2763  m_FourMuTree->Fill();
2764  }
2765  } // succesful 4mu reco
2766 
2767  } // end of fourMuon Analysis
2768 
2769  return thisStatus;
2770 }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_4mu

FourMuonEvent IDPerfMonZmumu::m_4mu
private

Definition at line 108 of file IDPerfMonZmumu.h.

◆ m_4mu_minv

double IDPerfMonZmumu::m_4mu_minv {}
private

Definition at line 357 of file IDPerfMonZmumu.h.

◆ m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> IDPerfMonZmumu::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
private

used for truth parameters

Definition at line 155 of file IDPerfMonZmumu.h.

◆ m_CBTrack_d0

std::vector<float> IDPerfMonZmumu::m_CBTrack_d0
private

Definition at line 387 of file IDPerfMonZmumu.h.

◆ m_CBTrack_eta

std::vector<float> IDPerfMonZmumu::m_CBTrack_eta
private

Definition at line 375 of file IDPerfMonZmumu.h.

◆ m_CBTrack_phi

std::vector<float> IDPerfMonZmumu::m_CBTrack_phi
private

Definition at line 381 of file IDPerfMonZmumu.h.

◆ m_CBTrack_pt

std::vector<float> IDPerfMonZmumu::m_CBTrack_pt
private

Definition at line 369 of file IDPerfMonZmumu.h.

◆ m_CBTrack_qoverp

std::vector<float> IDPerfMonZmumu::m_CBTrack_qoverp
private

Definition at line 399 of file IDPerfMonZmumu.h.

◆ m_CBTrack_sigma_d0

std::vector<float> IDPerfMonZmumu::m_CBTrack_sigma_d0
private

Definition at line 412 of file IDPerfMonZmumu.h.

◆ m_CBTrack_sigma_pt

std::vector<float> IDPerfMonZmumu::m_CBTrack_sigma_pt
private

Definition at line 407 of file IDPerfMonZmumu.h.

◆ m_CBTrack_sigma_qoverp

std::vector<float> IDPerfMonZmumu::m_CBTrack_sigma_qoverp
private

Definition at line 422 of file IDPerfMonZmumu.h.

◆ m_CBTrack_sigma_z0

std::vector<float> IDPerfMonZmumu::m_CBTrack_sigma_z0
private

Definition at line 417 of file IDPerfMonZmumu.h.

◆ m_CBTrack_z0

std::vector<float> IDPerfMonZmumu::m_CBTrack_z0
private

Definition at line 393 of file IDPerfMonZmumu.h.

◆ m_combTree

TTree* IDPerfMonZmumu::m_combTree
private

Definition at line 199 of file IDPerfMonZmumu.h.

◆ m_combTreeFolder

std::string IDPerfMonZmumu::m_combTreeFolder
private

Definition at line 188 of file IDPerfMonZmumu.h.

◆ m_combTreeName

std::string IDPerfMonZmumu::m_combTreeName
private

Definition at line 172 of file IDPerfMonZmumu.h.

◆ m_commonTree

TTree* IDPerfMonZmumu::m_commonTree
private

Definition at line 193 of file IDPerfMonZmumu.h.

◆ m_commonTreeFolder

std::string IDPerfMonZmumu::m_commonTreeFolder
private

Definition at line 182 of file IDPerfMonZmumu.h.

◆ m_commonTreeName

std::string IDPerfMonZmumu::m_commonTreeName
private

Definition at line 166 of file IDPerfMonZmumu.h.

◆ m_defaultTree

TTree* IDPerfMonZmumu::m_defaultTree
private

Definition at line 194 of file IDPerfMonZmumu.h.

◆ m_defaultTreeFolder

std::string IDPerfMonZmumu::m_defaultTreeFolder
private

Definition at line 183 of file IDPerfMonZmumu.h.

◆ m_defaultTreeName

std::string IDPerfMonZmumu::m_defaultTreeName
private

Definition at line 167 of file IDPerfMonZmumu.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doDebug

bool IDPerfMonZmumu::m_doDebug {}
private

Definition at line 207 of file IDPerfMonZmumu.h.

◆ m_doFourMuAnalysis

bool IDPerfMonZmumu::m_doFourMuAnalysis
private

Definition at line 123 of file IDPerfMonZmumu.h.

◆ m_doIP

bool IDPerfMonZmumu::m_doIP
private

Definition at line 122 of file IDPerfMonZmumu.h.

◆ m_doIPSelection

bool IDPerfMonZmumu::m_doIPSelection
private

Definition at line 111 of file IDPerfMonZmumu.h.

◆ m_doIsoSelection

bool IDPerfMonZmumu::m_doIsoSelection
private

Definition at line 110 of file IDPerfMonZmumu.h.

◆ m_doMCPSelection

bool IDPerfMonZmumu::m_doMCPSelection
private

Definition at line 112 of file IDPerfMonZmumu.h.

◆ m_doRefit

bool IDPerfMonZmumu::m_doRefit
private

Definition at line 120 of file IDPerfMonZmumu.h.

◆ m_doRemoval

bool IDPerfMonZmumu::m_doRemoval {}
private

Definition at line 206 of file IDPerfMonZmumu.h.

◆ m_el_negative1_d0

double IDPerfMonZmumu::m_el_negative1_d0 {}
private

Definition at line 308 of file IDPerfMonZmumu.h.

◆ m_el_negative1_d0_err

double IDPerfMonZmumu::m_el_negative1_d0_err {}
private

Definition at line 310 of file IDPerfMonZmumu.h.

◆ m_el_negative1_d0_PV

double IDPerfMonZmumu::m_el_negative1_d0_PV {}
private

Definition at line 312 of file IDPerfMonZmumu.h.

◆ m_el_negative1_d0_PVerr

double IDPerfMonZmumu::m_el_negative1_d0_PVerr {}
private

Definition at line 314 of file IDPerfMonZmumu.h.

◆ m_el_negative1_px

double IDPerfMonZmumu::m_el_negative1_px {}
private

Definition at line 304 of file IDPerfMonZmumu.h.

◆ m_el_negative1_py

double IDPerfMonZmumu::m_el_negative1_py {}
private

Definition at line 305 of file IDPerfMonZmumu.h.

◆ m_el_negative1_pz

double IDPerfMonZmumu::m_el_negative1_pz {}
private

Definition at line 306 of file IDPerfMonZmumu.h.

◆ m_el_negative1_vtx

int IDPerfMonZmumu::m_el_negative1_vtx {}
private

Definition at line 315 of file IDPerfMonZmumu.h.

◆ m_el_negative1_z0

double IDPerfMonZmumu::m_el_negative1_z0 {}
private

Definition at line 307 of file IDPerfMonZmumu.h.

◆ m_el_negative1_z0_err

double IDPerfMonZmumu::m_el_negative1_z0_err {}
private

Definition at line 309 of file IDPerfMonZmumu.h.

◆ m_el_negative1_z0_PV

double IDPerfMonZmumu::m_el_negative1_z0_PV {}
private

Definition at line 311 of file IDPerfMonZmumu.h.

◆ m_el_negative1_z0_PVerr

double IDPerfMonZmumu::m_el_negative1_z0_PVerr {}
private

Definition at line 313 of file IDPerfMonZmumu.h.

◆ m_el_negative2_d0

double IDPerfMonZmumu::m_el_negative2_d0 {}
private

Definition at line 321 of file IDPerfMonZmumu.h.

◆ m_el_negative2_d0_err

double IDPerfMonZmumu::m_el_negative2_d0_err {}
private

Definition at line 323 of file IDPerfMonZmumu.h.

◆ m_el_negative2_d0_PV

double IDPerfMonZmumu::m_el_negative2_d0_PV {}
private

Definition at line 325 of file IDPerfMonZmumu.h.

◆ m_el_negative2_d0_PVerr

double IDPerfMonZmumu::m_el_negative2_d0_PVerr {}
private

Definition at line 327 of file IDPerfMonZmumu.h.

◆ m_el_negative2_px

double IDPerfMonZmumu::m_el_negative2_px {}
private

Definition at line 317 of file IDPerfMonZmumu.h.

◆ m_el_negative2_py

double IDPerfMonZmumu::m_el_negative2_py {}
private

Definition at line 318 of file IDPerfMonZmumu.h.

◆ m_el_negative2_pz

double IDPerfMonZmumu::m_el_negative2_pz {}
private

Definition at line 319 of file IDPerfMonZmumu.h.

◆ m_el_negative2_vtx

int IDPerfMonZmumu::m_el_negative2_vtx {}
private

Definition at line 328 of file IDPerfMonZmumu.h.

◆ m_el_negative2_z0

double IDPerfMonZmumu::m_el_negative2_z0 {}
private

Definition at line 320 of file IDPerfMonZmumu.h.

◆ m_el_negative2_z0_err

double IDPerfMonZmumu::m_el_negative2_z0_err {}
private

Definition at line 322 of file IDPerfMonZmumu.h.

◆ m_el_negative2_z0_PV

double IDPerfMonZmumu::m_el_negative2_z0_PV {}
private

Definition at line 324 of file IDPerfMonZmumu.h.

◆ m_el_negative2_z0_PVerr

double IDPerfMonZmumu::m_el_negative2_z0_PVerr {}
private

Definition at line 326 of file IDPerfMonZmumu.h.

◆ m_el_positive1_d0

double IDPerfMonZmumu::m_el_positive1_d0 {}
private

Definition at line 334 of file IDPerfMonZmumu.h.

◆ m_el_positive1_d0_err

double IDPerfMonZmumu::m_el_positive1_d0_err {}
private

Definition at line 336 of file IDPerfMonZmumu.h.

◆ m_el_positive1_d0_PV

double IDPerfMonZmumu::m_el_positive1_d0_PV {}
private

Definition at line 338 of file IDPerfMonZmumu.h.

◆ m_el_positive1_px

double IDPerfMonZmumu::m_el_positive1_px {}
private

Definition at line 330 of file IDPerfMonZmumu.h.

◆ m_el_positive1_py

double IDPerfMonZmumu::m_el_positive1_py {}
private

Definition at line 331 of file IDPerfMonZmumu.h.

◆ m_el_positive1_pz

double IDPerfMonZmumu::m_el_positive1_pz {}
private

Definition at line 332 of file IDPerfMonZmumu.h.

◆ m_el_positive1_vtx

int IDPerfMonZmumu::m_el_positive1_vtx {}
private

Definition at line 341 of file IDPerfMonZmumu.h.

◆ m_el_positive1_z0

double IDPerfMonZmumu::m_el_positive1_z0 {}
private

Definition at line 333 of file IDPerfMonZmumu.h.

◆ m_el_positive1_z0_err

double IDPerfMonZmumu::m_el_positive1_z0_err {}
private

Definition at line 335 of file IDPerfMonZmumu.h.

◆ m_el_positive1_z0_PV

double IDPerfMonZmumu::m_el_positive1_z0_PV {}
private

Definition at line 337 of file IDPerfMonZmumu.h.

◆ m_el_positive1_z0_PVerr

double IDPerfMonZmumu::m_el_positive1_z0_PVerr {}
private

Definition at line 339 of file IDPerfMonZmumu.h.

◆ m_el_positive2_d0

double IDPerfMonZmumu::m_el_positive2_d0 {}
private

Definition at line 347 of file IDPerfMonZmumu.h.

◆ m_el_positive2_d0_err

double IDPerfMonZmumu::m_el_positive2_d0_err {}
private

Definition at line 349 of file IDPerfMonZmumu.h.

◆ m_el_positive2_d0_PV

double IDPerfMonZmumu::m_el_positive2_d0_PV {}
private

Definition at line 351 of file IDPerfMonZmumu.h.

◆ m_el_positive2_px

double IDPerfMonZmumu::m_el_positive2_px {}
private

Definition at line 343 of file IDPerfMonZmumu.h.

◆ m_el_positive2_py

double IDPerfMonZmumu::m_el_positive2_py {}
private

Definition at line 344 of file IDPerfMonZmumu.h.

◆ m_el_positive2_pz

double IDPerfMonZmumu::m_el_positive2_pz {}
private

Definition at line 345 of file IDPerfMonZmumu.h.

◆ m_el_positive2_vtx

int IDPerfMonZmumu::m_el_positive2_vtx {}
private

Definition at line 354 of file IDPerfMonZmumu.h.

◆ m_el_positive2_z0

double IDPerfMonZmumu::m_el_positive2_z0 {}
private

Definition at line 346 of file IDPerfMonZmumu.h.

◆ m_el_positive2_z0_err

double IDPerfMonZmumu::m_el_positive2_z0_err {}
private

Definition at line 348 of file IDPerfMonZmumu.h.

◆ m_el_positive2_z0_PV

double IDPerfMonZmumu::m_el_positive2_z0_PV {}
private

Definition at line 350 of file IDPerfMonZmumu.h.

◆ m_el_positive2_z0_PVerr

double IDPerfMonZmumu::m_el_positive2_z0_PVerr {}
private

Definition at line 352 of file IDPerfMonZmumu.h.

◆ m_el_psoitive1_d0_PVerr

double IDPerfMonZmumu::m_el_psoitive1_d0_PVerr {}
private

Definition at line 340 of file IDPerfMonZmumu.h.

◆ m_el_psoitive2_d0_PVerr

double IDPerfMonZmumu::m_el_psoitive2_d0_PVerr {}
private

Definition at line 353 of file IDPerfMonZmumu.h.

◆ m_event_mu

unsigned int IDPerfMonZmumu::m_event_mu {}
private

Definition at line 228 of file IDPerfMonZmumu.h.

◆ m_EventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> IDPerfMonZmumu::m_EventInfoKey {this, "EventInfoKey", "EventInfo"}
private

Definition at line 437 of file IDPerfMonZmumu.h.

◆ m_evtNumber

unsigned int IDPerfMonZmumu::m_evtNumber {}
private

Definition at line 226 of file IDPerfMonZmumu.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_extrapolator

ToolHandle<Trk::IExtrapolator> IDPerfMonZmumu::m_extrapolator
private

Definition at line 156 of file IDPerfMonZmumu.h.

◆ m_FourMuTree

TTree* IDPerfMonZmumu::m_FourMuTree
private

Definition at line 201 of file IDPerfMonZmumu.h.

◆ m_FourMuTreeFolder

std::string IDPerfMonZmumu::m_FourMuTreeFolder
private

Root Validation Tree.

Definition at line 190 of file IDPerfMonZmumu.h.

◆ m_FourMuTreeName

std::string IDPerfMonZmumu::m_FourMuTreeName
private

Definition at line 174 of file IDPerfMonZmumu.h.

◆ m_h_cutflow

TH1F* IDPerfMonZmumu::m_h_cutflow
private

link vector to map HepMC onto xAOD truth

Definition at line 223 of file IDPerfMonZmumu.h.

◆ m_IDTrack_d0

std::vector<float> IDPerfMonZmumu::m_IDTrack_d0
private

Definition at line 386 of file IDPerfMonZmumu.h.

◆ m_IDTrack_eta

std::vector<float> IDPerfMonZmumu::m_IDTrack_eta
private

Definition at line 374 of file IDPerfMonZmumu.h.

◆ m_IDTrack_phi

std::vector<float> IDPerfMonZmumu::m_IDTrack_phi
private

Definition at line 380 of file IDPerfMonZmumu.h.

◆ m_IDTrack_pt

std::vector<float> IDPerfMonZmumu::m_IDTrack_pt
private

Definition at line 368 of file IDPerfMonZmumu.h.

◆ m_IDTrack_qoverp

std::vector<float> IDPerfMonZmumu::m_IDTrack_qoverp
private

Definition at line 398 of file IDPerfMonZmumu.h.

◆ m_IDTrack_sigma_d0

std::vector<float> IDPerfMonZmumu::m_IDTrack_sigma_d0
private

Definition at line 411 of file IDPerfMonZmumu.h.

◆ m_IDTrack_sigma_pt

std::vector<float> IDPerfMonZmumu::m_IDTrack_sigma_pt
private

Definition at line 406 of file IDPerfMonZmumu.h.

◆ m_IDTrack_sigma_qoverp

std::vector<float> IDPerfMonZmumu::m_IDTrack_sigma_qoverp
private

Definition at line 421 of file IDPerfMonZmumu.h.

◆ m_IDTrack_sigma_z0

std::vector<float> IDPerfMonZmumu::m_IDTrack_sigma_z0
private

Definition at line 416 of file IDPerfMonZmumu.h.

◆ m_IDTrack_z0

std::vector<float> IDPerfMonZmumu::m_IDTrack_z0
private

Definition at line 392 of file IDPerfMonZmumu.h.

◆ m_IDTree

TTree* IDPerfMonZmumu::m_IDTree
private

Definition at line 195 of file IDPerfMonZmumu.h.

◆ m_IDTreeFolder

std::string IDPerfMonZmumu::m_IDTreeFolder
private

Definition at line 184 of file IDPerfMonZmumu.h.

◆ m_IDTreeName

std::string IDPerfMonZmumu::m_IDTreeName
private

Definition at line 168 of file IDPerfMonZmumu.h.

◆ m_isMC

bool IDPerfMonZmumu::m_isMC
private

Definition at line 119 of file IDPerfMonZmumu.h.

◆ m_LeadingMuonPtCut

double IDPerfMonZmumu::m_LeadingMuonPtCut
private

Definition at line 115 of file IDPerfMonZmumu.h.

◆ m_lumi_block

unsigned int IDPerfMonZmumu::m_lumi_block {}
private

Definition at line 227 of file IDPerfMonZmumu.h.

◆ m_MassWindowHigh

double IDPerfMonZmumu::m_MassWindowHigh
private

Definition at line 114 of file IDPerfMonZmumu.h.

◆ m_MassWindowLow

double IDPerfMonZmumu::m_MassWindowLow
private

Definition at line 113 of file IDPerfMonZmumu.h.

◆ m_maxGoodLumiBlock

int IDPerfMonZmumu::m_maxGoodLumiBlock
private

Definition at line 128 of file IDPerfMonZmumu.h.

◆ m_met

double IDPerfMonZmumu::m_met {}
private

Definition at line 364 of file IDPerfMonZmumu.h.

◆ m_metphi

double IDPerfMonZmumu::m_metphi {}
private

Definition at line 365 of file IDPerfMonZmumu.h.

◆ m_minGoodLumiBlock

int IDPerfMonZmumu::m_minGoodLumiBlock
private

Definition at line 127 of file IDPerfMonZmumu.h.

◆ m_MSTree

TTree* IDPerfMonZmumu::m_MSTree
private

Definition at line 200 of file IDPerfMonZmumu.h.

◆ m_MSTreeFolder

std::string IDPerfMonZmumu::m_MSTreeFolder
private

Definition at line 189 of file IDPerfMonZmumu.h.

◆ m_MSTreeName

std::string IDPerfMonZmumu::m_MSTreeName
private

Definition at line 173 of file IDPerfMonZmumu.h.

◆ m_MuonQualityName

std::string IDPerfMonZmumu::m_MuonQualityName
private

Definition at line 434 of file IDPerfMonZmumu.h.

◆ m_muonSelector

ToolHandle<CP::IMuonSelectionTool> IDPerfMonZmumu::m_muonSelector
private

used to pass a custom muon selector

Definition at line 159 of file IDPerfMonZmumu.h.

◆ m_nBLhits

std::vector<int> IDPerfMonZmumu::m_nBLhits
private

Definition at line 426 of file IDPerfMonZmumu.h.

◆ m_negative_1_vtx

int IDPerfMonZmumu::m_negative_1_vtx {}
private

Definition at line 287 of file IDPerfMonZmumu.h.

◆ m_negative_2_d0

double IDPerfMonZmumu::m_negative_2_d0 {}
private

Definition at line 294 of file IDPerfMonZmumu.h.

◆ m_negative_2_d0_err

double IDPerfMonZmumu::m_negative_2_d0_err {}
private

Definition at line 296 of file IDPerfMonZmumu.h.

◆ m_negative_2_d0_PV

double IDPerfMonZmumu::m_negative_2_d0_PV {}
private

Definition at line 298 of file IDPerfMonZmumu.h.

◆ m_negative_2_d0_PVerr

double IDPerfMonZmumu::m_negative_2_d0_PVerr {}
private

Definition at line 300 of file IDPerfMonZmumu.h.

◆ m_negative_2_px

double IDPerfMonZmumu::m_negative_2_px {}
private

Definition at line 290 of file IDPerfMonZmumu.h.

◆ m_negative_2_py

double IDPerfMonZmumu::m_negative_2_py {}
private

Definition at line 291 of file IDPerfMonZmumu.h.

◆ m_negative_2_pz

double IDPerfMonZmumu::m_negative_2_pz {}
private

Definition at line 292 of file IDPerfMonZmumu.h.

◆ m_negative_2_vtx

int IDPerfMonZmumu::m_negative_2_vtx {}
private

Definition at line 301 of file IDPerfMonZmumu.h.

◆ m_negative_2_z0

double IDPerfMonZmumu::m_negative_2_z0 {}
private

Definition at line 293 of file IDPerfMonZmumu.h.

◆ m_negative_2_z0_err

double IDPerfMonZmumu::m_negative_2_z0_err {}
private

Definition at line 295 of file IDPerfMonZmumu.h.

◆ m_negative_2_z0_PV

double IDPerfMonZmumu::m_negative_2_z0_PV {}
private

Definition at line 297 of file IDPerfMonZmumu.h.

◆ m_negative_2_z0_PVerr

double IDPerfMonZmumu::m_negative_2_z0_PVerr {}
private

Definition at line 299 of file IDPerfMonZmumu.h.

◆ m_negative_d0

double IDPerfMonZmumu::m_negative_d0 {}
private

Definition at line 275 of file IDPerfMonZmumu.h.

◆ m_negative_d0_err

double IDPerfMonZmumu::m_negative_d0_err {}
private

Definition at line 279 of file IDPerfMonZmumu.h.

◆ m_negative_d0_manualBS

double IDPerfMonZmumu::m_negative_d0_manualBS {}
private

Definition at line 277 of file IDPerfMonZmumu.h.

◆ m_negative_d0_PV

double IDPerfMonZmumu::m_negative_d0_PV {}
private

Definition at line 282 of file IDPerfMonZmumu.h.

◆ m_negative_d0_PVerr

double IDPerfMonZmumu::m_negative_d0_PVerr {}
private

Definition at line 284 of file IDPerfMonZmumu.h.

◆ m_negative_eta

double IDPerfMonZmumu::m_negative_eta {}
private

Definition at line 273 of file IDPerfMonZmumu.h.

◆ m_negative_parent

int IDPerfMonZmumu::m_negative_parent {}
private

Definition at line 288 of file IDPerfMonZmumu.h.

◆ m_negative_phi

double IDPerfMonZmumu::m_negative_phi {}
private

Definition at line 272 of file IDPerfMonZmumu.h.

◆ m_negative_pt

double IDPerfMonZmumu::m_negative_pt {}
private

Definition at line 270 of file IDPerfMonZmumu.h.

◆ m_negative_px

double IDPerfMonZmumu::m_negative_px {}
private

Definition at line 268 of file IDPerfMonZmumu.h.

◆ m_negative_py

double IDPerfMonZmumu::m_negative_py {}
private

Definition at line 269 of file IDPerfMonZmumu.h.

◆ m_negative_pz

double IDPerfMonZmumu::m_negative_pz {}
private

Definition at line 271 of file IDPerfMonZmumu.h.

◆ m_negative_qoverp

double IDPerfMonZmumu::m_negative_qoverp {}
private

Definition at line 285 of file IDPerfMonZmumu.h.

◆ m_negative_sigma_pt

double IDPerfMonZmumu::m_negative_sigma_pt {}
private

Definition at line 280 of file IDPerfMonZmumu.h.

◆ m_negative_sigma_qoverp

double IDPerfMonZmumu::m_negative_sigma_qoverp {}
private

Definition at line 286 of file IDPerfMonZmumu.h.

◆ m_negative_z0

double IDPerfMonZmumu::m_negative_z0 {}
private

Definition at line 274 of file IDPerfMonZmumu.h.

◆ m_negative_z0_err

double IDPerfMonZmumu::m_negative_z0_err {}
private

Definition at line 278 of file IDPerfMonZmumu.h.

◆ m_negative_z0_manualBS

double IDPerfMonZmumu::m_negative_z0_manualBS {}
private

Definition at line 276 of file IDPerfMonZmumu.h.

◆ m_negative_z0_PV

double IDPerfMonZmumu::m_negative_z0_PV {}
private

Definition at line 281 of file IDPerfMonZmumu.h.

◆ m_negative_z0_PVerr

double IDPerfMonZmumu::m_negative_z0_PVerr {}
private

Definition at line 283 of file IDPerfMonZmumu.h.

◆ m_nPIXhits

std::vector<int> IDPerfMonZmumu::m_nPIXhits
private

Definition at line 427 of file IDPerfMonZmumu.h.

◆ m_nSCThits

std::vector<int> IDPerfMonZmumu::m_nSCThits
private

Definition at line 428 of file IDPerfMonZmumu.h.

◆ m_nTrkInVtx

unsigned int IDPerfMonZmumu::m_nTrkInVtx {}
private

Definition at line 362 of file IDPerfMonZmumu.h.

◆ m_nTRThits

std::vector<int> IDPerfMonZmumu::m_nTRThits
private

Definition at line 429 of file IDPerfMonZmumu.h.

◆ m_nVertex

unsigned int IDPerfMonZmumu::m_nVertex {}
private

Definition at line 231 of file IDPerfMonZmumu.h.

◆ m_OpeningAngleCut

double IDPerfMonZmumu::m_OpeningAngleCut
private

Definition at line 117 of file IDPerfMonZmumu.h.

◆ m_outputTracksName

std::string IDPerfMonZmumu::m_outputTracksName
private

Definition at line 433 of file IDPerfMonZmumu.h.

◆ m_positive_1_vtx

int IDPerfMonZmumu::m_positive_1_vtx {}
private

Definition at line 252 of file IDPerfMonZmumu.h.

◆ m_positive_2_d0

double IDPerfMonZmumu::m_positive_2_d0 {}
private

Definition at line 259 of file IDPerfMonZmumu.h.

◆ m_positive_2_d0_err

double IDPerfMonZmumu::m_positive_2_d0_err {}
private

Definition at line 261 of file IDPerfMonZmumu.h.

◆ m_positive_2_d0_PV

double IDPerfMonZmumu::m_positive_2_d0_PV {}
private

Definition at line 263 of file IDPerfMonZmumu.h.

◆ m_positive_2_d0_PVerr

double IDPerfMonZmumu::m_positive_2_d0_PVerr {}
private

Definition at line 265 of file IDPerfMonZmumu.h.

◆ m_positive_2_px

double IDPerfMonZmumu::m_positive_2_px {}
private

Definition at line 255 of file IDPerfMonZmumu.h.

◆ m_positive_2_py

double IDPerfMonZmumu::m_positive_2_py {}
private

Definition at line 256 of file IDPerfMonZmumu.h.

◆ m_positive_2_pz

double IDPerfMonZmumu::m_positive_2_pz {}
private

Definition at line 257 of file IDPerfMonZmumu.h.

◆ m_positive_2_vtx

int IDPerfMonZmumu::m_positive_2_vtx {}
private

Definition at line 266 of file IDPerfMonZmumu.h.

◆ m_positive_2_z0

double IDPerfMonZmumu::m_positive_2_z0 {}
private

Definition at line 258 of file IDPerfMonZmumu.h.

◆ m_positive_2_z0_err

double IDPerfMonZmumu::m_positive_2_z0_err {}
private

Definition at line 260 of file IDPerfMonZmumu.h.

◆ m_positive_2_z0_PV

double IDPerfMonZmumu::m_positive_2_z0_PV {}
private

Definition at line 262 of file IDPerfMonZmumu.h.

◆ m_positive_2_z0_PVerr

double IDPerfMonZmumu::m_positive_2_z0_PVerr {}
private

Definition at line 264 of file IDPerfMonZmumu.h.

◆ m_positive_d0

double IDPerfMonZmumu::m_positive_d0 {}
private

Definition at line 240 of file IDPerfMonZmumu.h.

◆ m_positive_d0_err

double IDPerfMonZmumu::m_positive_d0_err {}
private

Definition at line 244 of file IDPerfMonZmumu.h.

◆ m_positive_d0_manualBS

double IDPerfMonZmumu::m_positive_d0_manualBS {}
private

Definition at line 242 of file IDPerfMonZmumu.h.

◆ m_positive_d0_PV

double IDPerfMonZmumu::m_positive_d0_PV {}
private

Definition at line 247 of file IDPerfMonZmumu.h.

◆ m_positive_d0_PVerr

double IDPerfMonZmumu::m_positive_d0_PVerr {}
private

Definition at line 249 of file IDPerfMonZmumu.h.

◆ m_positive_eta

double IDPerfMonZmumu::m_positive_eta {}
private

Definition at line 238 of file IDPerfMonZmumu.h.

◆ m_positive_parent

int IDPerfMonZmumu::m_positive_parent {}
private

Definition at line 253 of file IDPerfMonZmumu.h.

◆ m_positive_phi

double IDPerfMonZmumu::m_positive_phi {}
private

Definition at line 237 of file IDPerfMonZmumu.h.

◆ m_positive_pt

double IDPerfMonZmumu::m_positive_pt {}
private

Definition at line 235 of file IDPerfMonZmumu.h.

◆ m_positive_px

double IDPerfMonZmumu::m_positive_px {}
private

Definition at line 233 of file IDPerfMonZmumu.h.

◆ m_positive_py

double IDPerfMonZmumu::m_positive_py {}
private

Definition at line 234 of file IDPerfMonZmumu.h.

◆ m_positive_pz

double IDPerfMonZmumu::m_positive_pz {}
private

Definition at line 236 of file IDPerfMonZmumu.h.

◆ m_positive_qoverp

double IDPerfMonZmumu::m_positive_qoverp {}
private

Definition at line 250 of file IDPerfMonZmumu.h.

◆ m_positive_sigma_pt

double IDPerfMonZmumu::m_positive_sigma_pt {}
private

Definition at line 245 of file IDPerfMonZmumu.h.

◆ m_positive_sigma_qoverp

double IDPerfMonZmumu::m_positive_sigma_qoverp {}
private

Definition at line 251 of file IDPerfMonZmumu.h.

◆ m_positive_z0

double IDPerfMonZmumu::m_positive_z0 {}
private

Definition at line 239 of file IDPerfMonZmumu.h.

◆ m_positive_z0_err

double IDPerfMonZmumu::m_positive_z0_err {}
private

Definition at line 243 of file IDPerfMonZmumu.h.

◆ m_positive_z0_manualBS

double IDPerfMonZmumu::m_positive_z0_manualBS {}
private

Definition at line 241 of file IDPerfMonZmumu.h.

◆ m_positive_z0_PV

double IDPerfMonZmumu::m_positive_z0_PV {}
private

Definition at line 246 of file IDPerfMonZmumu.h.

◆ m_positive_z0_PVerr

double IDPerfMonZmumu::m_positive_z0_PVerr {}
private

Definition at line 248 of file IDPerfMonZmumu.h.

◆ m_pv_x

double IDPerfMonZmumu::m_pv_x {}
private

Definition at line 359 of file IDPerfMonZmumu.h.

◆ m_pv_y

double IDPerfMonZmumu::m_pv_y {}
private

Definition at line 360 of file IDPerfMonZmumu.h.

◆ m_pv_z

double IDPerfMonZmumu::m_pv_z {}
private

Definition at line 361 of file IDPerfMonZmumu.h.

◆ m_Refit1_d0

std::vector<float> IDPerfMonZmumu::m_Refit1_d0
private

Definition at line 388 of file IDPerfMonZmumu.h.

◆ m_Refit1_eta

std::vector<float> IDPerfMonZmumu::m_Refit1_eta
private

Definition at line 376 of file IDPerfMonZmumu.h.

◆ m_Refit1_phi

std::vector<float> IDPerfMonZmumu::m_Refit1_phi
private

Definition at line 382 of file IDPerfMonZmumu.h.

◆ m_Refit1_pt

std::vector<float> IDPerfMonZmumu::m_Refit1_pt
private

Definition at line 370 of file IDPerfMonZmumu.h.

◆ m_Refit1_qoverp

std::vector<float> IDPerfMonZmumu::m_Refit1_qoverp
private

Definition at line 400 of file IDPerfMonZmumu.h.

◆ m_Refit1_sigma_d0

std::vector<float> IDPerfMonZmumu::m_Refit1_sigma_d0
private

Definition at line 413 of file IDPerfMonZmumu.h.

◆ m_Refit1_sigma_pt

std::vector<float> IDPerfMonZmumu::m_Refit1_sigma_pt
private

Definition at line 408 of file IDPerfMonZmumu.h.

◆ m_Refit1_sigma_qoverp

std::vector<float> IDPerfMonZmumu::m_Refit1_sigma_qoverp
private

Definition at line 423 of file IDPerfMonZmumu.h.

◆ m_Refit1_sigma_z0

std::vector<float> IDPerfMonZmumu::m_Refit1_sigma_z0
private

Definition at line 418 of file IDPerfMonZmumu.h.

◆ m_Refit1_z0

std::vector<float> IDPerfMonZmumu::m_Refit1_z0
private

Definition at line 394 of file IDPerfMonZmumu.h.

◆ m_refit1Tree

TTree* IDPerfMonZmumu::m_refit1Tree
private

Definition at line 196 of file IDPerfMonZmumu.h.

◆ m_refit1TreeFolder

std::string IDPerfMonZmumu::m_refit1TreeFolder
private

Definition at line 185 of file IDPerfMonZmumu.h.

◆ m_refit1TreeName

std::string IDPerfMonZmumu::m_refit1TreeName
private

Definition at line 169 of file IDPerfMonZmumu.h.

◆ m_Refit2_d0

std::vector<float> IDPerfMonZmumu::m_Refit2_d0
private

Definition at line 389 of file IDPerfMonZmumu.h.

◆ m_Refit2_eta

std::vector<float> IDPerfMonZmumu::m_Refit2_eta
private

Definition at line 377 of file IDPerfMonZmumu.h.

◆ m_Refit2_phi

std::vector<float> IDPerfMonZmumu::m_Refit2_phi
private

Definition at line 383 of file IDPerfMonZmumu.h.

◆ m_Refit2_pt

std::vector<float> IDPerfMonZmumu::m_Refit2_pt
private

Definition at line 371 of file IDPerfMonZmumu.h.

◆ m_Refit2_qoverp

std::vector<float> IDPerfMonZmumu::m_Refit2_qoverp
private

Definition at line 401 of file IDPerfMonZmumu.h.

◆ m_Refit2_sigma_d0

std::vector<float> IDPerfMonZmumu::m_Refit2_sigma_d0
private

Definition at line 414 of file IDPerfMonZmumu.h.

◆ m_Refit2_sigma_pt

std::vector<float> IDPerfMonZmumu::m_Refit2_sigma_pt
private

Definition at line 409 of file IDPerfMonZmumu.h.

◆ m_Refit2_sigma_qoverp

std::vector<float> IDPerfMonZmumu::m_Refit2_sigma_qoverp
private

Definition at line 424 of file IDPerfMonZmumu.h.

◆ m_Refit2_sigma_z0

std::vector<float> IDPerfMonZmumu::m_Refit2_sigma_z0
private

Definition at line 419 of file IDPerfMonZmumu.h.

◆ m_Refit2_z0

std::vector<float> IDPerfMonZmumu::m_Refit2_z0
private

Definition at line 395 of file IDPerfMonZmumu.h.

◆ m_refit2Tree

TTree* IDPerfMonZmumu::m_refit2Tree
private

Definition at line 197 of file IDPerfMonZmumu.h.

◆ m_refit2TreeFolder

std::string IDPerfMonZmumu::m_refit2TreeFolder
private

Definition at line 186 of file IDPerfMonZmumu.h.

◆ m_refit2TreeName

std::string IDPerfMonZmumu::m_refit2TreeName
private

Definition at line 170 of file IDPerfMonZmumu.h.

◆ m_runNumber

unsigned int IDPerfMonZmumu::m_runNumber {}
private

Definition at line 225 of file IDPerfMonZmumu.h.

◆ m_SecondMuonPtCut

double IDPerfMonZmumu::m_SecondMuonPtCut
private

Definition at line 116 of file IDPerfMonZmumu.h.

◆ m_selTool

ToolHandle< InDet::IInDetTrackSelectionTool > IDPerfMonZmumu::m_selTool
private

The track selection Tool.

Definition at line 148 of file IDPerfMonZmumu.h.

◆ m_skipMS

bool IDPerfMonZmumu::m_skipMS
private

Definition at line 125 of file IDPerfMonZmumu.h.

◆ m_storeZmumuNtuple

bool IDPerfMonZmumu::m_storeZmumuNtuple
private

Definition at line 124 of file IDPerfMonZmumu.h.

◆ m_sTriggerChainName

std::string IDPerfMonZmumu::m_sTriggerChainName
private

Definition at line 432 of file IDPerfMonZmumu.h.

◆ m_trackContainerName

SG::ReadHandleKey<xAOD::TrackParticleContainer> IDPerfMonZmumu::m_trackContainerName {this, "trackContainerName", "InDetTrackParticles"}
private

IDTtacks.

Definition at line 215 of file IDPerfMonZmumu.h.

◆ m_trackParticleName

std::string IDPerfMonZmumu::m_trackParticleName
private

Track(Particle)TruthCollection input name.

Definition at line 219 of file IDPerfMonZmumu.h.

◆ m_TrackRefitter1

ToolHandle<IegammaTrkRefitterTool> IDPerfMonZmumu::m_TrackRefitter1
private

The track refitter.

Definition at line 132 of file IDPerfMonZmumu.h.

◆ m_TrackRefitter2

ToolHandle<IegammaTrkRefitterTool> IDPerfMonZmumu::m_TrackRefitter2
private

The track refitter.

Definition at line 135 of file IDPerfMonZmumu.h.

◆ m_trackToVertexIPEstimator

ToolHandle< Trk::ITrackToVertexIPEstimator > IDPerfMonZmumu::m_trackToVertexIPEstimator
private

Needed for IP resolution studies.

Definition at line 152 of file IDPerfMonZmumu.h.

◆ m_trackToVertexTool

ToolHandle<Reco::ITrackToVertex> IDPerfMonZmumu::m_trackToVertexTool
private

tool to extrapolate tracks to BL

Definition at line 138 of file IDPerfMonZmumu.h.

◆ m_triggerDecision

ToolHandle<Trig::TrigDecisionTool> IDPerfMonZmumu::m_triggerDecision
private

Definition at line 141 of file IDPerfMonZmumu.h.

◆ m_triggerMatching

ToolHandle<Trig::IMatchingTool> IDPerfMonZmumu::m_triggerMatching
private

Definition at line 145 of file IDPerfMonZmumu.h.

◆ m_triggerName

std::string IDPerfMonZmumu::m_triggerName
private

Definition at line 230 of file IDPerfMonZmumu.h.

◆ m_triggerPrescale

int IDPerfMonZmumu::m_triggerPrescale
private

Definition at line 229 of file IDPerfMonZmumu.h.

◆ m_Trk2VtxAssociationTool

ToolHandle< CP::ITrackVertexAssociationTool > IDPerfMonZmumu::m_Trk2VtxAssociationTool
private

Definition at line 209 of file IDPerfMonZmumu.h.

◆ m_Truth_d0

std::vector<float> IDPerfMonZmumu::m_Truth_d0
private

Definition at line 390 of file IDPerfMonZmumu.h.

◆ m_Truth_eta

std::vector<float> IDPerfMonZmumu::m_Truth_eta
private

Definition at line 378 of file IDPerfMonZmumu.h.

◆ m_Truth_parent

std::vector<int> IDPerfMonZmumu::m_Truth_parent
private

Definition at line 404 of file IDPerfMonZmumu.h.

◆ m_Truth_phi

std::vector<float> IDPerfMonZmumu::m_Truth_phi
private

Definition at line 384 of file IDPerfMonZmumu.h.

◆ m_Truth_pt

std::vector<float> IDPerfMonZmumu::m_Truth_pt
private

Definition at line 372 of file IDPerfMonZmumu.h.

◆ m_Truth_qoverp

std::vector<float> IDPerfMonZmumu::m_Truth_qoverp
private

Definition at line 402 of file IDPerfMonZmumu.h.

◆ m_Truth_z0

std::vector<float> IDPerfMonZmumu::m_Truth_z0
private

Definition at line 396 of file IDPerfMonZmumu.h.

◆ m_truthLinkVecName

std::string IDPerfMonZmumu::m_truthLinkVecName
private

TrackParticle input name.

Definition at line 220 of file IDPerfMonZmumu.h.

◆ m_truthName

std::string IDPerfMonZmumu::m_truthName
private

Definition at line 218 of file IDPerfMonZmumu.h.

◆ m_truthTree

TTree* IDPerfMonZmumu::m_truthTree
private

Definition at line 198 of file IDPerfMonZmumu.h.

◆ m_truthTreeFolder

std::string IDPerfMonZmumu::m_truthTreeFolder
private

Definition at line 187 of file IDPerfMonZmumu.h.

◆ m_truthTreeName

std::string IDPerfMonZmumu::m_truthTreeName
private

Definition at line 171 of file IDPerfMonZmumu.h.

◆ m_useCustomMuonSelector

bool IDPerfMonZmumu::m_useCustomMuonSelector
private

Definition at line 126 of file IDPerfMonZmumu.h.

◆ m_useTrackSelectionTool

bool IDPerfMonZmumu::m_useTrackSelectionTool
private

Definition at line 121 of file IDPerfMonZmumu.h.

◆ m_UseTrigger

bool IDPerfMonZmumu::m_UseTrigger
private

Definition at line 109 of file IDPerfMonZmumu.h.

◆ m_validationMode

bool IDPerfMonZmumu::m_validationMode
private

< boolean to switch to validation mode

validation tree name - to be acessed by this from root

Definition at line 163 of file IDPerfMonZmumu.h.

◆ m_ValidationTreeDescription

std::string IDPerfMonZmumu::m_ValidationTreeDescription
private

< validation tree description - second argument in TTree

stream/folder to for the TTree to be written out

Definition at line 179 of file IDPerfMonZmumu.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vertexKey

SG::ReadHandleKey<xAOD::VertexContainer> IDPerfMonZmumu::m_vertexKey { this, "VertexContainer", "PrimaryVertices", "primary vertex container" }
private

Definition at line 212 of file IDPerfMonZmumu.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_xZmm

ZmumuEvent IDPerfMonZmumu::m_xZmm
private

Definition at line 107 of file IDPerfMonZmumu.h.

◆ m_Z0GapCut

double IDPerfMonZmumu::m_Z0GapCut
private

Definition at line 118 of file IDPerfMonZmumu.h.

The documentation for this class was generated from the following files:
IDPerfMonZmumu::m_positive_sigma_qoverp
double m_positive_sigma_qoverp
Definition: IDPerfMonZmumu.h:251
IDPerfMonZmumu::m_doIP
bool m_doIP
Definition: IDPerfMonZmumu.h:122
IDPerfMonZmumu::m_negative_d0_manualBS
double m_negative_d0_manualBS
Definition: IDPerfMonZmumu.h:277
IDPerfMonZmumu::m_el_positive2_vtx
int m_el_positive2_vtx
Definition: IDPerfMonZmumu.h:354
IDPerfMonZmumu::m_negative_2_px
double m_negative_2_px
Definition: IDPerfMonZmumu.h:290
IDPerfMonZmumu::m_IDTrack_sigma_z0
std::vector< float > m_IDTrack_sigma_z0
Definition: IDPerfMonZmumu.h:416
IDPerfMonZmumu::m_doDebug
bool m_doDebug
Definition: IDPerfMonZmumu.h:207
IDPerfMonZmumu::m_selTool
ToolHandle< InDet::IInDetTrackSelectionTool > m_selTool
The track selection Tool.
Definition: IDPerfMonZmumu.h:148
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
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
IDPerfMonZmumu::m_positive_d0
double m_positive_d0
Definition: IDPerfMonZmumu.h:240
IDPerfMonZmumu::m_el_negative2_pz
double m_el_negative2_pz
Definition: IDPerfMonZmumu.h:319
IDPerfMonZmumu::m_el_positive1_z0_err
double m_el_positive1_z0_err
Definition: IDPerfMonZmumu.h:335
IDPerfMonZmumu::m_IDTreeFolder
std::string m_IDTreeFolder
Definition: IDPerfMonZmumu.h:184
IDPerfMonZmumu::m_defaultTreeName
std::string m_defaultTreeName
Definition: IDPerfMonZmumu.h:167
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
IDPerfMonZmumu::m_positive_z0
double m_positive_z0
Definition: IDPerfMonZmumu.h:239
IDPerfMonZmumu::m_combTreeName
std::string m_combTreeName
Definition: IDPerfMonZmumu.h:172
IDPerfMonZmumu::m_nSCThits
std::vector< int > m_nSCThits
Definition: IDPerfMonZmumu.h:428
IDPerfMonZmumu::m_el_negative1_vtx
int m_el_negative1_vtx
Definition: IDPerfMonZmumu.h:315
IDPerfMonZmumu::m_Refit1_qoverp
std::vector< float > m_Refit1_qoverp
Definition: IDPerfMonZmumu.h:400
FourMuonEvent::Init
void Init()
Definition: FourMuonEvent.cxx:64
IDPerfMonZmumu::m_el_negative2_vtx
int m_el_negative2_vtx
Definition: IDPerfMonZmumu.h:328
IDPerfMonZmumu::m_positive_1_vtx
int m_positive_1_vtx
Definition: IDPerfMonZmumu.h:252
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
IDPerfMonZmumu::m_FourMuTree
TTree * m_FourMuTree
Definition: IDPerfMonZmumu.h:201
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:76
IDPerfMonZmumu::m_trackToVertexTool
ToolHandle< Reco::ITrackToVertex > m_trackToVertexTool
tool to extrapolate tracks to BL
Definition: IDPerfMonZmumu.h:138
IDPerfMonZmumu::m_nBLhits
std::vector< int > m_nBLhits
Definition: IDPerfMonZmumu.h:426
IDPerfMonZmumu::m_truthTree
TTree * m_truthTree
Definition: IDPerfMonZmumu.h:198
IDPerfMonZmumu::m_triggerMatching
ToolHandle< Trig::IMatchingTool > m_triggerMatching
Definition: IDPerfMonZmumu.h:145
IDPerfMonZmumu::m_4mu_minv
double m_4mu_minv
Definition: IDPerfMonZmumu.h:357
IDPerfMonZmumu::m_truthTreeFolder
std::string m_truthTreeFolder
Definition: IDPerfMonZmumu.h:187
IDPerfMonZmumu::m_negative_parent
int m_negative_parent
Definition: IDPerfMonZmumu.h:288
IDPerfMonZmumu::m_Refit1_phi
std::vector< float > m_Refit1_phi
Definition: IDPerfMonZmumu.h:382
get_generator_info.result
result
Definition: get_generator_info.py:21
IDPerfMonZmumu::m_truthLinkVecName
std::string m_truthLinkVecName
TrackParticle input name.
Definition: IDPerfMonZmumu.h:220
test_pyathena.px
px
Definition: test_pyathena.py:18
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
IDPerfMonZmumu::m_Trk2VtxAssociationTool
ToolHandle< CP::ITrackVertexAssociationTool > m_Trk2VtxAssociationTool
Definition: IDPerfMonZmumu.h:209
IDPerfMonZmumu::m_el_positive2_pz
double m_el_positive2_pz
Definition: IDPerfMonZmumu.h:345
FourMuonEvent::getELTrack
const xAOD::TrackParticle * getELTrack(unsigned int uPart)
Definition: FourMuonEvent.h:80
IDPerfMonZmumu::m_nPIXhits
std::vector< int > m_nPIXhits
Definition: IDPerfMonZmumu.h:427
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
IDPerfMonZmumu::m_negative_2_vtx
int m_negative_2_vtx
Definition: IDPerfMonZmumu.h:301
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
FourMuonEvent::GetVertexMuPos2
int GetVertexMuPos2()
Definition: FourMuonEvent.h:100
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
IDPerfMonZmumu::m_el_negative1_py
double m_el_negative1_py
Definition: IDPerfMonZmumu.h:305
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
IDPerfMonZmumu::m_positive_qoverp
double m_positive_qoverp
Definition: IDPerfMonZmumu.h:250
IDPerfMonZmumu::m_Refit1_sigma_pt
std::vector< float > m_Refit1_sigma_pt
Definition: IDPerfMonZmumu.h:408
FourMuonEvent::SetZ0GapCut
void SetZ0GapCut(double newvalue)
Definition: FourMuonEvent.h:116
IDPerfMonZmumu::m_Truth_d0
std::vector< float > m_Truth_d0
Definition: IDPerfMonZmumu.h:390
IDPerfMonZmumu::m_CBTrack_d0
std::vector< float > m_CBTrack_d0
Definition: IDPerfMonZmumu.h:387
FourMuonEvent::SetMuonSelectionTool
void SetMuonSelectionTool(ToolHandle< CP::IMuonSelectionTool > mst)
Definition: FourMuonEvent.h:113
xAOD::TrackParticle_v1::charge
float charge() const
Returns the charge.
Definition: TrackParticle_v1.cxx:150
IDPerfMonZmumu::m_Refit2_z0
std::vector< float > m_Refit2_z0
Definition: IDPerfMonZmumu.h:395
Trk::PerigeeSurface
Definition: PerigeeSurface.h:43
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
IDPerfMonZmumu::m_defaultTree
TTree * m_defaultTree
Definition: IDPerfMonZmumu.h:194
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
IDPerfMonZmumu::m_TrackRefitter2
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter2
The track refitter.
Definition: IDPerfMonZmumu.h:135
IDPerfMonZmumu::m_CBTrack_phi
std::vector< float > m_CBTrack_phi
Definition: IDPerfMonZmumu.h:381
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
IDPerfMonZmumu::m_Truth_qoverp
std::vector< float > m_Truth_qoverp
Definition: IDPerfMonZmumu.h:402
IDPerfMonZmumu::m_doRemoval
bool m_doRemoval
Definition: IDPerfMonZmumu.h:206
IDPerfMonZmumu::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Definition: IDPerfMonZmumu.h:437
FourMuonEvent::Reco
bool Reco()
Definition: FourMuonEvent.cxx:84
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:736
IDPerfMonZmumu::m_FourMuTreeName
std::string m_FourMuTreeName
Definition: IDPerfMonZmumu.h:174
IDPerfMonZmumu::m_IDTrack_sigma_qoverp
std::vector< float > m_IDTrack_sigma_qoverp
Definition: IDPerfMonZmumu.h:421
IDPerfMonZmumu::m_CBTrack_eta
std::vector< float > m_CBTrack_eta
Definition: IDPerfMonZmumu.h:375
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
FourMuonEvent::GetNVertex
int GetNVertex()
Definition: FourMuonEvent.h:88
xAOD::JetInput::Track
@ Track
Definition: JetContainerInfo.h:61
IDPerfMonZmumu::m_negative_2_pz
double m_negative_2_pz
Definition: IDPerfMonZmumu.h:292
ZmumuEvent::getMSTrack
const xAOD::TrackParticle * getMSTrack(unsigned int uPart)
Definition: ZmumuEvent.h:75
IDPerfMonZmumu::m_trackContainerName
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackContainerName
IDTtacks.
Definition: IDPerfMonZmumu.h:215
test_pyathena.pt
pt
Definition: test_pyathena.py:11
IDPerfMonZmumu::m_met
double m_met
Definition: IDPerfMonZmumu.h:364
IDPerfMonZmumu::m_positive_2_d0
double m_positive_2_d0
Definition: IDPerfMonZmumu.h:259
IDPerfMonZmumu::m_isMC
bool m_isMC
Definition: IDPerfMonZmumu.h:119
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
ParticleTest.tp
tp
Definition: ParticleTest.py:25
Trk::z0
@ z0
Definition: ParamDefs.h:70
xAOD::TrackParticle_v1::definingParametersCovMatrixVec
std::vector< float > definingParametersCovMatrixVec() const
Returns the length 6 vector containing the elements of defining parameters covariance matrix.
Definition: TrackParticle_v1.cxx:385
FourMuonEvent::SetMassWindowHigh
void SetMassWindowHigh(double newvalue)
Definition: FourMuonEvent.h:111
IDPerfMonZmumu::m_positive_py
double m_positive_py
Definition: IDPerfMonZmumu.h:234
IDPerfMonZmumu::CheckTriggerStatusAndPrescale
StatusCode CheckTriggerStatusAndPrescale()
Definition: IDPerfMonZmumu.cxx:2292
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
IDPerfMonZmumu::m_refit2Tree
TTree * m_refit2Tree
Definition: IDPerfMonZmumu.h:197
IDPerfMonZmumu::bookTrees
StatusCode bookTrees()
Definition: IDPerfMonZmumu.cxx:312
SG::ConstAccessor< float >
IDPerfMonZmumu::m_el_positive1_d0_err
double m_el_positive1_d0_err
Definition: IDPerfMonZmumu.h:336
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
IDPerfMonZmumu::m_negative_2_py
double m_negative_2_py
Definition: IDPerfMonZmumu.h:291
IDPerfMonZmumu::m_CBTrack_sigma_qoverp
std::vector< float > m_CBTrack_sigma_qoverp
Definition: IDPerfMonZmumu.h:422
InDetAccessor::qOverP
@ qOverP
perigee
Definition: InDetAccessor.h:35
IDPerfMonZmumu::m_CBTrack_pt
std::vector< float > m_CBTrack_pt
Definition: IDPerfMonZmumu.h:369
IDPerfMonZmumu::m_negative_px
double m_negative_px
Definition: IDPerfMonZmumu.h:268
ZmumuEvent::getNegMuon
unsigned int getNegMuon(ZTYPE eType)
Definition: ZmumuEvent.cxx:549
IDPerfMonZmumu::m_Truth_pt
std::vector< float > m_Truth_pt
Definition: IDPerfMonZmumu.h:372
IDPerfMonZmumu::m_positive_px
double m_positive_px
Definition: IDPerfMonZmumu.h:233
IDPerfMonZmumu::m_el_negative2_px
double m_el_negative2_px
Definition: IDPerfMonZmumu.h:317
IDPerfMonZmumu::m_refit1TreeFolder
std::string m_refit1TreeFolder
Definition: IDPerfMonZmumu.h:185
IDPerfMonZmumu::m_Refit2_eta
std::vector< float > m_Refit2_eta
Definition: IDPerfMonZmumu.h:377
IDPerfMonZmumu::m_truthName
std::string m_truthName
Definition: IDPerfMonZmumu.h:218
IDPerfMonZmumu::m_el_negative1_px
double m_el_negative1_px
Definition: IDPerfMonZmumu.h:304
FourMuonEvent::GetVertexMuNeg1
int GetVertexMuNeg1()
Definition: FourMuonEvent.h:97
IDPerfMonZmumu::m_LeadingMuonPtCut
double m_LeadingMuonPtCut
Definition: IDPerfMonZmumu.h:115
xAOD::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the first pixel layer, i.e.
Definition: TrackingPrimitives.h:231
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
IDPerfMonZmumu::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
used for truth parameters
Definition: IDPerfMonZmumu.h:155
IDPerfMonZmumu::m_positive_d0_manualBS
double m_positive_d0_manualBS
Definition: IDPerfMonZmumu.h:242
IDPerfMonZmumu::m_pv_z
double m_pv_z
Definition: IDPerfMonZmumu.h:361
xAOD::TrackParticle_v1::d0
float d0() const
Returns the parameter.
IDPerfMonZmumu::m_nTrkInVtx
unsigned int m_nTrkInVtx
Definition: IDPerfMonZmumu.h:362
IDPerfMonZmumu::m_el_positive1_py
double m_el_positive1_py
Definition: IDPerfMonZmumu.h:331
IDPerfMonZmumu::m_positive_z0_manualBS
double m_positive_z0_manualBS
Definition: IDPerfMonZmumu.h:241
IDPerfMonZmumu::m_TrackRefitter1
ToolHandle< IegammaTrkRefitterTool > m_TrackRefitter1
The track refitter.
Definition: IDPerfMonZmumu.h:132
ZmumuEvent::SetMaxLumiBlock
void SetMaxLumiBlock(int newlumiblock)
Definition: ZmumuEvent.h:89
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
IDPerfMonZmumu::m_MSTreeName
std::string m_MSTreeName
Definition: IDPerfMonZmumu.h:173
IDPerfMonZmumu::m_maxGoodLumiBlock
int m_maxGoodLumiBlock
Definition: IDPerfMonZmumu.h:128
IDPerfMonZmumu::m_positive_z0_PV
double m_positive_z0_PV
Definition: IDPerfMonZmumu.h:246
FourMuonEvent::EventPassed
bool EventPassed()
Definition: FourMuonEvent.h:76
IDPerfMonZmumu::m_Refit1_z0
std::vector< float > m_Refit1_z0
Definition: IDPerfMonZmumu.h:394
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IegammaTrkRefitterTool::Cache
Struct Holding the result to return and intermediate objects Things are owned by the EDM or the uniqu...
Definition: IegammaTrkRefitterTool.h:39
IDPerfMonZmumu::m_el_positive1_d0
double m_el_positive1_d0
Definition: IDPerfMonZmumu.h:334
IDPerfMonZmumu::m_xZmm
ZmumuEvent m_xZmm
Definition: IDPerfMonZmumu.h:107
IDPerfMonZmumu::m_negative_d0_PV
double m_negative_d0_PV
Definition: IDPerfMonZmumu.h:282
IDPerfMonZmumu::m_positive_2_pz
double m_positive_2_pz
Definition: IDPerfMonZmumu.h:257
IDPerfMonZmumu::m_commonTree
TTree * m_commonTree
Definition: IDPerfMonZmumu.h:193
FourMuonEvent::doIPSelection
void doIPSelection(bool doIPsel)
Definition: FourMuonEvent.h:74
IDPerfMonZmumu::m_minGoodLumiBlock
int m_minGoodLumiBlock
Definition: IDPerfMonZmumu.h:127
IDPerfMonZmumu::m_IDTrack_d0
std::vector< float > m_IDTrack_d0
Definition: IDPerfMonZmumu.h:386
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:129
IDPerfMonZmumu::m_validationMode
bool m_validationMode
< boolean to switch to validation mode
Definition: IDPerfMonZmumu.h:163
IDPerfMonZmumu::m_trackParticleName
std::string m_trackParticleName
Track(Particle)TruthCollection input name.
Definition: IDPerfMonZmumu.h:219
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
IDPerfMonZmumu::m_positive_pz
double m_positive_pz
Definition: IDPerfMonZmumu.h:236
FourMuonEvent::getNegMuon
unsigned int getNegMuon(int eType)
Definition: FourMuonEvent.cxx:1277
IDPerfMonZmumu::m_doMCPSelection
bool m_doMCPSelection
Definition: IDPerfMonZmumu.h:112
xAOD::TrackParticle_v1::perigeeParameters
const Trk::Perigee & perigeeParameters() const
Returns the Trk::MeasuredPerigee track parameters.
Definition: TrackParticle_v1.cxx:485
IDPerfMonZmumu::m_ValidationTreeDescription
std::string m_ValidationTreeDescription
< validation tree description - second argument in TTree
Definition: IDPerfMonZmumu.h:179
met
Definition: IMETSignificance.h:24
IDPerfMonZmumu::m_refit2TreeFolder
std::string m_refit2TreeFolder
Definition: IDPerfMonZmumu.h:186
IDPerfMonZmumu::FillTruthParameters
StatusCode FillTruthParameters(const xAOD::TrackParticle *track)
Definition: IDPerfMonZmumu.cxx:2074
FourMuonEvent::GetInvMass
double GetInvMass()
Definition: FourMuonEvent.h:82
IDPerfMonZmumu::m_el_negative1_z0_err
double m_el_negative1_z0_err
Definition: IDPerfMonZmumu.h:309
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
IDPerfMonZmumu::m_Refit1_sigma_z0
std::vector< float > m_Refit1_sigma_z0
Definition: IDPerfMonZmumu.h:418
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
IDPerfMonZmumu::m_Refit2_qoverp
std::vector< float > m_Refit2_qoverp
Definition: IDPerfMonZmumu.h:401
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
IDPerfMonZmumu::m_skipMS
bool m_skipMS
Definition: IDPerfMonZmumu.h:125
IDPerfMonZmumu::m_CBTrack_sigma_pt
std::vector< float > m_CBTrack_sigma_pt
Definition: IDPerfMonZmumu.h:407
IDPerfMonZmumu::m_IDTree
TTree * m_IDTree
Definition: IDPerfMonZmumu.h:195
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
FourMuonEvent::getPosMuon
unsigned int getPosMuon(int eType)
Definition: FourMuonEvent.cxx:1266
IDPerfMonZmumu::m_positive_parent
int m_positive_parent
Definition: IDPerfMonZmumu.h:253
FourMuonEvent::GetVertexMuPos1
int GetVertexMuPos1()
Definition: FourMuonEvent.h:99
IDPerfMonZmumu::m_IDTrack_phi
std::vector< float > m_IDTrack_phi
Definition: IDPerfMonZmumu.h:380
lumiFormat.i
int i
Definition: lumiFormat.py:92
SG::OWN_ELEMENTS
@ OWN_ELEMENTS
this data object owns its elements
Definition: OwnershipPolicy.h:17
TrackCollection
DataVector< Trk::Track > TrackCollection
This typedef represents a collection of Trk::Track objects.
Definition: TrackCollection.h:19
IDPerfMonZmumu::m_positive_2_z0_err
double m_positive_2_z0_err
Definition: IDPerfMonZmumu.h:260
IDPerfMonZmumu::m_el_positive2_d0_err
double m_el_positive2_d0_err
Definition: IDPerfMonZmumu.h:349
IDPerfMonZmumu::m_CBTrack_sigma_z0
std::vector< float > m_CBTrack_sigma_z0
Definition: IDPerfMonZmumu.h:417
IDPerfMonZmumu::m_el_positive1_px
double m_el_positive1_px
Definition: IDPerfMonZmumu.h:330
IDPerfMonZmumu::m_runNumber
unsigned int m_runNumber
Definition: IDPerfMonZmumu.h:225
Trk::theta
@ theta
Definition: ParamDefs.h:72
IDPerfMonZmumu::m_combTreeFolder
std::string m_combTreeFolder
Definition: IDPerfMonZmumu.h:188
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:41
IDPerfMonZmumu::m_Refit1_sigma_qoverp
std::vector< float > m_Refit1_sigma_qoverp
Definition: IDPerfMonZmumu.h:423
IDPerfMonZmumu::m_doRefit
bool m_doRefit
Definition: IDPerfMonZmumu.h:120
IDPerfMonZmumu::m_el_negative1_z0
double m_el_negative1_z0
Definition: IDPerfMonZmumu.h:307
IDPerfMonZmumu::m_IDTrack_eta
std::vector< float > m_IDTrack_eta
Definition: IDPerfMonZmumu.h:374
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
IDPerfMonZmumu::m_positive_2_py
double m_positive_2_py
Definition: IDPerfMonZmumu.h:256
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
xAOD::MissingET_v1
Principal data object for Missing ET.
Definition: MissingET_v1.h:25
FourMuonEvent::SetLeadingMuonPtCut
void SetLeadingMuonPtCut(double newvalue)
Definition: FourMuonEvent.cxx:1322
IDPerfMonZmumu::m_negative_pt
double m_negative_pt
Definition: IDPerfMonZmumu.h:270
IDPerfMonZmumu::m_IDTrack_z0
std::vector< float > m_IDTrack_z0
Definition: IDPerfMonZmumu.h:392
AthenaPoolTestRead.acc
acc
Definition: AthenaPoolTestRead.py:16
IDPerfMonZmumu::m_MuonQualityName
std::string m_MuonQualityName
Definition: IDPerfMonZmumu.h:434
python.xAODType.dummy
dummy
Definition: xAODType.py:4
IDPerfMonZmumu::m_positive_d0_err
double m_positive_d0_err
Definition: IDPerfMonZmumu.h:244
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IDPerfMonZmumu::m_triggerPrescale
int m_triggerPrescale
Definition: IDPerfMonZmumu.h:229
IDPerfMonZmumu::m_Refit1_eta
std::vector< float > m_Refit1_eta
Definition: IDPerfMonZmumu.h:376
IDPerfMonZmumu::m_IDTrack_sigma_d0
std::vector< float > m_IDTrack_sigma_d0
Definition: IDPerfMonZmumu.h:411
ZmumuEvent::AcceptEvent
bool AcceptEvent()
Definition: ZmumuEvent.h:67
IDPerfMonZmumu::m_negative_d0_PVerr
double m_negative_d0_PVerr
Definition: IDPerfMonZmumu.h:284
IDPerfMonZmumu::m_IDTrack_sigma_pt
std::vector< float > m_IDTrack_sigma_pt
Definition: IDPerfMonZmumu.h:406
IDPerfMonZmumu::m_metphi
double m_metphi
Definition: IDPerfMonZmumu.h:365
IDPerfMonZmumu::m_CBTrack_sigma_d0
std::vector< float > m_CBTrack_sigma_d0
Definition: IDPerfMonZmumu.h:412
IDPerfMonZmumu::m_nTRThits
std::vector< int > m_nTRThits
Definition: IDPerfMonZmumu.h:429
IDPerfMonZmumu::m_lumi_block
unsigned int m_lumi_block
Definition: IDPerfMonZmumu.h:227
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
IDPerfMonZmumu::m_Refit1_pt
std::vector< float > m_Refit1_pt
Definition: IDPerfMonZmumu.h:370
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
IDPerfMonZmumu::m_UseTrigger
bool m_UseTrigger
Definition: IDPerfMonZmumu.h:109
Trk::CurvilinearParametersT
Definition: CurvilinearParametersT.h:48
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
PerfMonServices::VTX_COLLECTION
@ VTX_COLLECTION
Definition: PerfMonServices.h:65
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
IDPerfMonZmumu::m_outputTracksName
std::string m_outputTracksName
Definition: IDPerfMonZmumu.h:433
IDPerfMonZmumu::m_Refit2_phi
std::vector< float > m_Refit2_phi
Definition: IDPerfMonZmumu.h:383
IDPerfMonZmumu::m_combTree
TTree * m_combTree
Definition: IDPerfMonZmumu.h:199
IDPerfMonZmumu::m_el_positive1_vtx
int m_el_positive1_vtx
Definition: IDPerfMonZmumu.h:341
DataVector< Trk::Track >
ZmumuEvent::doMCPSelection
void doMCPSelection(bool doMCP)
Definition: ZmumuEvent.h:66
ZmumuEvent::getCombMuon
const xAOD::Muon * getCombMuon(unsigned int uPart)
Definition: ZmumuEvent.h:70
IDPerfMonZmumu::m_positive_2_vtx
int m_positive_2_vtx
Definition: IDPerfMonZmumu.h:266
IDPerfMonZmumu::m_negative_qoverp
double m_negative_qoverp
Definition: IDPerfMonZmumu.h:285
IDPerfMonZmumu::m_el_negative2_z0_err
double m_el_negative2_z0_err
Definition: IDPerfMonZmumu.h:322
IDPerfMonZmumu::m_el_positive2_py
double m_el_positive2_py
Definition: IDPerfMonZmumu.h:344
IDPerfMonZmumu::m_negative_d0_err
double m_negative_d0_err
Definition: IDPerfMonZmumu.h:279
IDPerfMonZmumu::m_Refit2_d0
std::vector< float > m_Refit2_d0
Definition: IDPerfMonZmumu.h:389
IDPerfMonZmumu::m_positive_2_d0_err
double m_positive_2_d0_err
Definition: IDPerfMonZmumu.h:261
IDPerfMonZmumu::FillRecParametersSimple
StatusCode FillRecParametersSimple(const Trk::Track *track, float charge, const xAOD::Vertex *vertex)
Definition: IDPerfMonZmumu.cxx:1980
IDPerfMonZmumu::getTruthParticle
const xAOD::TruthParticle * getTruthParticle(const xAOD::IParticle &p)
Definition: IDPerfMonZmumu.cxx:2265
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
IDPerfMonZmumu::m_OpeningAngleCut
double m_OpeningAngleCut
Definition: IDPerfMonZmumu.h:117
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
IDPerfMonZmumu::ResetCommonNtupleVectors
void ResetCommonNtupleVectors()
Definition: IDPerfMonZmumu.cxx:2372
IDPerfMonZmumu::m_negative_pz
double m_negative_pz
Definition: IDPerfMonZmumu.h:271
IDPerfMonZmumu::m_negative_2_d0_err
double m_negative_2_d0_err
Definition: IDPerfMonZmumu.h:296
IDPerfMonZmumu::m_negative_eta
double m_negative_eta
Definition: IDPerfMonZmumu.h:273
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
xAOD::TruthVertex_v1
Class describing a truth vertex in the MC record.
Definition: TruthVertex_v1.h:41
xAOD::MissingETContainer_v1
Container for xAOD::MissingET_v1 objects.
Definition: MissingETContainer_v1.h:21
ZmumuEvent::doIPSelection
void doIPSelection(bool doIPsel)
Definition: ZmumuEvent.h:65
Trk::ParametersBase::pT
double pT() const
Access method for transverse momentum.
FourMuonEvent::getAcceptedEvents
int getAcceptedEvents()
Definition: FourMuonEvent.h:78
IDPerfMonZmumu::m_Truth_z0
std::vector< float > m_Truth_z0
Definition: IDPerfMonZmumu.h:396
Amg::py
@ py
Definition: GeoPrimitives.h:39
xAOD::TrackParticle_v1::qOverP
float qOverP() const
Returns the parameter.
IDPerfMonZmumu::m_negative_z0_PVerr
double m_negative_z0_PVerr
Definition: IDPerfMonZmumu.h:283
xAOD::TrackParticle_v1::definingParametersCovMatrix
const ParametersCovMatrix_t definingParametersCovMatrix() const
Returns the 5x5 symmetric matrix containing the defining parameters covariance matrix.
Definition: TrackParticle_v1.cxx:246
ZmumuEvent::setDebugMode
void setDebugMode(bool debug)
Definition: ZmumuEvent.h:88
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
IDPerfMonZmumu::m_negative_1_vtx
int m_negative_1_vtx
Definition: IDPerfMonZmumu.h:287
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
Trk::d0
@ d0
Definition: ParamDefs.h:69
IDPerfMonZmumu::m_useCustomMuonSelector
bool m_useCustomMuonSelector
Definition: IDPerfMonZmumu.h:126
ZmumuEvent::SetMuonSelectionTool
void SetMuonSelectionTool(ToolHandle< CP::IMuonSelectionTool > mst)
Definition: ZmumuEvent.h:103
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
IDPerfMonZmumu::m_vertexKey
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexKey
Definition: IDPerfMonZmumu.h:212
IDPerfMonZmumu::m_el_positive2_d0
double m_el_positive2_d0
Definition: IDPerfMonZmumu.h:347
FourMuonEvent::setDebugMode
void setDebugMode(bool debug)
Definition: FourMuonEvent.h:108
ZmumuEvent::doIsoSelection
void doIsoSelection(bool doIso)
Definition: ZmumuEvent.h:64
IDPerfMonZmumu::m_Truth_phi
std::vector< float > m_Truth_phi
Definition: IDPerfMonZmumu.h:384
charge
double charge(const T &p)
Definition: AtlasPID.h:494
IDPerfMonZmumu::m_MSTreeFolder
std::string m_MSTreeFolder
Definition: IDPerfMonZmumu.h:189
IDPerfMonZmumu::m_Refit2_sigma_pt
std::vector< float > m_Refit2_sigma_pt
Definition: IDPerfMonZmumu.h:409
FourMuonEvent::setContainer
void setContainer(PerfMonServices::CONTAINERS container)
Definition: FourMuonEvent.h:107
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
IDPerfMonZmumu::m_el_negative2_py
double m_el_negative2_py
Definition: IDPerfMonZmumu.h:318
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
IDPerfMonZmumu::m_el_negative2_d0
double m_el_negative2_d0
Definition: IDPerfMonZmumu.h:321
IDPerfMonZmumu::m_positive_2_z0
double m_positive_2_z0
Definition: IDPerfMonZmumu.h:258
IDPerfMonZmumu::m_positive_phi
double m_positive_phi
Definition: IDPerfMonZmumu.h:237
IDPerfMonZmumu::m_MSTree
TTree * m_MSTree
Definition: IDPerfMonZmumu.h:200
IDPerfMonZmumu::m_Refit1_sigma_d0
std::vector< float > m_Refit1_sigma_d0
Definition: IDPerfMonZmumu.h:413
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
IDPerfMonZmumu::m_muonSelector
ToolHandle< CP::IMuonSelectionTool > m_muonSelector
used to pass a custom muon selector
Definition: IDPerfMonZmumu.h:159
IDPerfMonZmumu::m_negative_2_d0
double m_negative_2_d0
Definition: IDPerfMonZmumu.h:294
IDPerfMonZmumu::m_sTriggerChainName
std::string m_sTriggerChainName
Definition: IDPerfMonZmumu.h:432
IDPerfMonZmumu::m_negative_d0
double m_negative_d0
Definition: IDPerfMonZmumu.h:275
IDPerfMonZmumu::m_trackToVertexIPEstimator
ToolHandle< Trk::ITrackToVertexIPEstimator > m_trackToVertexIPEstimator
Needed for IP resolution studies.
Definition: IDPerfMonZmumu.h:152
IDPerfMonZmumu::m_refit1TreeName
std::string m_refit1TreeName
Definition: IDPerfMonZmumu.h:169
IDPerfMonZmumu::m_el_positive1_pz
double m_el_positive1_pz
Definition: IDPerfMonZmumu.h:332
ZmumuEvent::SetSecondMuonPtCut
void SetSecondMuonPtCut(double newvalue)
Definition: ZmumuEvent.cxx:617
ZmumuEvent::SetMuonQuality
void SetMuonQuality(const std::string &newname)
Definition: ZmumuEvent.h:92
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
IDPerfMonZmumu::m_Z0GapCut
double m_Z0GapCut
Definition: IDPerfMonZmumu.h:118
IDPerfMonZmumu::m_nVertex
unsigned int m_nVertex
Definition: IDPerfMonZmumu.h:231
IDPerfMonZmumu::m_commonTreeFolder
std::string m_commonTreeFolder
Definition: IDPerfMonZmumu.h:182
ZmumuEvent::SetLeadingMuonPtCut
void SetLeadingMuonPtCut(double newvalue)
Definition: ZmumuEvent.cxx:600
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
IDPerfMonZmumu::m_positive_d0_PVerr
double m_positive_d0_PVerr
Definition: IDPerfMonZmumu.h:249
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
ZmumuEvent::SetMinLumiBlock
void SetMinLumiBlock(int newlumiblock)
Definition: ZmumuEvent.h:90
IDPerfMonZmumu::m_el_positive2_z0
double m_el_positive2_z0
Definition: IDPerfMonZmumu.h:346
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
ZmumuEvent::GetInvMass
double GetInvMass()
Definition: ZmumuEvent.h:72
IDPerfMonZmumu::m_el_positive2_z0_err
double m_el_positive2_z0_err
Definition: IDPerfMonZmumu.h:348
IDPerfMonZmumu::m_positive_d0_PV
double m_positive_d0_PV
Definition: IDPerfMonZmumu.h:247
IDPerfMonZmumu::FillRecParametersTP
StatusCode FillRecParametersTP(const xAOD::TrackParticle *trackp, const xAOD::TrackParticle *trackp_for_unbias, double charge, const xAOD::Vertex *vertex=nullptr)
Definition: IDPerfMonZmumu.cxx:1668
IDPerfMonZmumu::m_IDTreeName
std::string m_IDTreeName
Definition: IDPerfMonZmumu.h:168
IDPerfMonZmumu::Clear4MuNtupleVariables
void Clear4MuNtupleVariables()
Definition: IDPerfMonZmumu.cxx:2441
a
TList * a
Definition: liststreamerinfos.cxx:10
IDPerfMonZmumu::m_useTrackSelectionTool
bool m_useTrackSelectionTool
Definition: IDPerfMonZmumu.h:121
IDPerfMonZmumu::m_el_negative1_pz
double m_el_negative1_pz
Definition: IDPerfMonZmumu.h:306
ZmumuEvent::CB
@ CB
Definition: ZmumuEvent.h:55
IDPerfMonZmumu::m_positive_z0_err
double m_positive_z0_err
Definition: IDPerfMonZmumu.h:243
h
IDPerfMonZmumu::m_positive_eta
double m_positive_eta
Definition: IDPerfMonZmumu.h:238
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ZmumuEvent::finalize
void finalize()
Definition: ZmumuEvent.cxx:669
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
IDPerfMonZmumu::m_el_negative1_d0_err
double m_el_negative1_d0_err
Definition: IDPerfMonZmumu.h:310
IDPerfMonZmumu::m_event_mu
unsigned int m_event_mu
Definition: IDPerfMonZmumu.h:228
IDPerfMonZmumu::m_CBTrack_z0
std::vector< float > m_CBTrack_z0
Definition: IDPerfMonZmumu.h:393
IDPerfMonZmumu::m_positive_pt
double m_positive_pt
Definition: IDPerfMonZmumu.h:235
IDPerfMonZmumu::RunFourLeptonAnalysis
StatusCode RunFourLeptonAnalysis()
Definition: IDPerfMonZmumu.cxx:2532
IDPerfMonZmumu::m_triggerName
std::string m_triggerName
Definition: IDPerfMonZmumu.h:230
IDPerfMonZmumu::m_negative_z0
double m_negative_z0
Definition: IDPerfMonZmumu.h:274
IDPerfMonZmumu::m_negative_py
double m_negative_py
Definition: IDPerfMonZmumu.h:269
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
IDPerfMonZmumu::m_negative_phi
double m_negative_phi
Definition: IDPerfMonZmumu.h:272
ZmumuEvent::SetOpeningAngleCut
void SetOpeningAngleCut(double newvalue)
Definition: ZmumuEvent.h:98
IDPerfMonZmumu::m_positive_2_px
double m_positive_2_px
Definition: IDPerfMonZmumu.h:255
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
IDPerfMonZmumu::m_el_positive1_z0
double m_el_positive1_z0
Definition: IDPerfMonZmumu.h:333
FourMuonEvent::doMCPSelection
void doMCPSelection(bool doMCP)
Definition: FourMuonEvent.h:75
IDPerfMonZmumu::m_negative_sigma_qoverp
double m_negative_sigma_qoverp
Definition: IDPerfMonZmumu.h:286
IDPerfMonZmumu::m_negative_z0_err
double m_negative_z0_err
Definition: IDPerfMonZmumu.h:278
FourMuonEvent::GetVertexElec
int GetVertexElec(unsigned int uPart)
Definition: FourMuonEvent.h:92
IDPerfMonZmumu::m_Refit1_d0
std::vector< float > m_Refit1_d0
Definition: IDPerfMonZmumu.h:388
IDPerfMonZmumu::m_MassWindowHigh
double m_MassWindowHigh
Definition: IDPerfMonZmumu.h:114
IDPerfMonZmumu::m_refit1Tree
TTree * m_refit1Tree
Definition: IDPerfMonZmumu.h:196
xAOD::numberOfContribPixelLayers
@ numberOfContribPixelLayers
number of contributing layers of the pixel detector [unit8_t].
Definition: TrackingPrimitives.h:230
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
IDPerfMonZmumu::m_doIsoSelection
bool m_doIsoSelection
Definition: IDPerfMonZmumu.h:110
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
IDPerfMonZmumu::m_Truth_eta
std::vector< float > m_Truth_eta
Definition: IDPerfMonZmumu.h:378
IDPerfMonZmumu::m_el_positive2_px
double m_el_positive2_px
Definition: IDPerfMonZmumu.h:343
IDPerfMonZmumu::m_Refit2_sigma_qoverp
std::vector< float > m_Refit2_sigma_qoverp
Definition: IDPerfMonZmumu.h:424
Trk::ParametersBase::eta
double eta() const
Access method for pseudorapidity - from momentum.
IDPerfMonZmumu::m_extrapolator
ToolHandle< Trk::IExtrapolator > m_extrapolator
Definition: IDPerfMonZmumu.h:156
FourMuonEvent::SetMassWindowLow
void SetMassWindowLow(double newvalue)
Definition: FourMuonEvent.h:110
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
Trk::phi
@ phi
Definition: ParamDefs.h:81
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
IDPerfMonZmumu::m_doIPSelection
bool m_doIPSelection
Definition: IDPerfMonZmumu.h:111
IDPerfMonZmumu::m_el_negative1_d0
double m_el_negative1_d0
Definition: IDPerfMonZmumu.h:308
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
IDPerfMonZmumu::ExtractIDHitsInformation
void ExtractIDHitsInformation(const xAOD::Muon *muon_pos, const xAOD::Muon *muon_neg)
Definition: IDPerfMonZmumu.cxx:2773
xAOD::TrackParticle_v1::track
const Trk::Track * track() const
Returns a pointer (which can be NULL) to the Trk::Track which was used to make this TrackParticle.
Definition: TrackParticle_v1.cxx:805
IDPerfMonZmumu::m_evtNumber
unsigned int m_evtNumber
Definition: IDPerfMonZmumu.h:226
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
IDPerfMonZmumu::m_triggerDecision
ToolHandle< Trig::TrigDecisionTool > m_triggerDecision
Definition: IDPerfMonZmumu.h:141
IDPerfMonZmumu::m_h_cutflow
TH1F * m_h_cutflow
link vector to map HepMC onto xAOD truth
Definition: IDPerfMonZmumu.h:223
ZmumuEvent::SetSkipMSCheck
void SetSkipMSCheck(bool value)
Definition: ZmumuEvent.h:100
IDPerfMonZmumu::m_negative_2_z0_err
double m_negative_2_z0_err
Definition: IDPerfMonZmumu.h:295
IDPerfMonZmumu::m_pv_y
double m_pv_y
Definition: IDPerfMonZmumu.h:360
IDPerfMonZmumu::m_negative_z0_PV
double m_negative_z0_PV
Definition: IDPerfMonZmumu.h:281
IDPerfMonZmumu::m_positive_z0_PVerr
double m_positive_z0_PVerr
Definition: IDPerfMonZmumu.h:248
IDPerfMonZmumu::m_SecondMuonPtCut
double m_SecondMuonPtCut
Definition: IDPerfMonZmumu.h:116
PerfMonServices::InitialiseServices
static StatusCode InitialiseServices(ISvcLocator *pxSvcLocator)
Definition: PerfMonServices.cxx:50
IDPerfMonZmumu::m_negative_2_z0
double m_negative_2_z0
Definition: IDPerfMonZmumu.h:293
IDPerfMonZmumu::m_4mu
FourMuonEvent m_4mu
Definition: IDPerfMonZmumu.h:108
FourMuonEvent::SetOpeningAngleCut
void SetOpeningAngleCut(double newvalue)
Definition: FourMuonEvent.h:115
ZmumuEvent::SetMassWindowHigh
void SetMassWindowHigh(double newvalue)
Definition: ZmumuEvent.h:95
IDPerfMonZmumu::m_Refit2_pt
std::vector< float > m_Refit2_pt
Definition: IDPerfMonZmumu.h:371
IDPerfMonZmumu::m_el_negative2_z0
double m_el_negative2_z0
Definition: IDPerfMonZmumu.h:320
IDPerfMonZmumu::m_Truth_parent
std::vector< int > m_Truth_parent
Definition: IDPerfMonZmumu.h:404
IDPerfMonZmumu::m_pv_x
double m_pv_x
Definition: IDPerfMonZmumu.h:359
IDPerfMonZmumu::m_Refit2_sigma_d0
std::vector< float > m_Refit2_sigma_d0
Definition: IDPerfMonZmumu.h:414
ZmumuEvent::SetZ0GapCut
void SetZ0GapCut(double newvalue)
Definition: ZmumuEvent.h:99
IDPerfMonZmumu::m_commonTreeName
std::string m_commonTreeName
Definition: IDPerfMonZmumu.h:166
xAOD::TrackParticle_v1::theta
float theta() const
Returns the parameter, which has range 0 to .
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
IDPerfMonZmumu::m_truthTreeName
std::string m_truthTreeName
Definition: IDPerfMonZmumu.h:171
ZmumuEvent::getPosMuon
unsigned int getPosMuon(ZTYPE eType)
Definition: ZmumuEvent.cxx:516
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
IDPerfMonZmumu::m_Refit2_sigma_z0
std::vector< float > m_Refit2_sigma_z0
Definition: IDPerfMonZmumu.h:419
IDPerfMonZmumu::m_negative_z0_manualBS
double m_negative_z0_manualBS
Definition: IDPerfMonZmumu.h:276
IDPerfMonZmumu::m_IDTrack_qoverp
std::vector< float > m_IDTrack_qoverp
Definition: IDPerfMonZmumu.h:398
FourMuonEvent::GetVertexMuNeg2
int GetVertexMuNeg2()
Definition: FourMuonEvent.h:98
IDPerfMonZmumu::m_refit2TreeName
std::string m_refit2TreeName
Definition: IDPerfMonZmumu.h:170
FourMuonEvent::SetSecondMuonPtCut
void SetSecondMuonPtCut(double newvalue)
Definition: FourMuonEvent.cxx:1342
ZmumuEvent::setContainer
void setContainer(PerfMonServices::CONTAINERS container)
Definition: ZmumuEvent.h:102
ZmumuEvent::SetMassWindowLow
void SetMassWindowLow(double newvalue)
Definition: ZmumuEvent.h:94
IDPerfMonZmumu::m_CBTrack_qoverp
std::vector< float > m_CBTrack_qoverp
Definition: IDPerfMonZmumu.h:399
IDPerfMonZmumu::m_storeZmumuNtuple
bool m_storeZmumuNtuple
Definition: IDPerfMonZmumu.h:124
PerfMonServices::MUON_COLLECTION
@ MUON_COLLECTION
Definition: PerfMonServices.h:45
FourMuonEvent::doIsoSelection
void doIsoSelection(bool doIso)
Definition: FourMuonEvent.h:73
IDPerfMonZmumu::m_MassWindowLow
double m_MassWindowLow
Definition: IDPerfMonZmumu.h:113
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
IDPerfMonZmumu::m_defaultTreeFolder
std::string m_defaultTreeFolder
Definition: IDPerfMonZmumu.h:183
fitman.k
k
Definition: fitman.py:528
FourMuonEvent::getIDTrack
const xAOD::TrackParticle * getIDTrack(unsigned int uPart)
Definition: FourMuonEvent.h:81
IDPerfMonZmumu::m_IDTrack_pt
std::vector< float > m_IDTrack_pt
Definition: IDPerfMonZmumu.h:368
ZmumuEvent::Reco
virtual bool Reco(int theLumiBlock=0)
Definition: ZmumuEvent.cxx:111
IDPerfMonZmumu::m_el_negative2_d0_err
double m_el_negative2_d0_err
Definition: IDPerfMonZmumu.h:323
IDPerfMonZmumu::m_negative_sigma_pt
double m_negative_sigma_pt
Definition: IDPerfMonZmumu.h:280
ServiceHandle< ICondSvc >
IDPerfMonZmumu::m_doFourMuAnalysis
bool m_doFourMuAnalysis
Definition: IDPerfMonZmumu.h:123
IDPerfMonZmumu::m_FourMuTreeFolder
std::string m_FourMuTreeFolder
Root Validation Tree.
Definition: IDPerfMonZmumu.h:190
IDPerfMonZmumu::m_positive_sigma_pt
double m_positive_sigma_pt
Definition: IDPerfMonZmumu.h:245
Generated on Fri Jul 5 2024 21:46:43 for ATLAS Offline Software by   doxygen 1.8.18