IDPerfMonZmumu.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef IDPERFMON_ZMUMU_H
#define IDPERFMON_ZMUMU_H
 
//==============================================================================
// Include files...
//==============================================================================
#include "AthenaMonitoring/ManagedMonitorToolBase.h"
#include "InDetPerformanceMonitoring/ZmumuEvent.h"
#include "InDetPerformanceMonitoring/FourMuonEvent.h"
#include "InDetPerformanceMonitoring/EventAnalysis.h"
#include "InDetPerformanceMonitoring/MuonSelector.h"
 
#include "xAODTruth/TruthVertex.h"
#include "xAODTruth/TruthParticle.h"
#include "xAODTruth/TruthParticleContainer.h"
#include "ITrackToVertex/ITrackToVertex.h"
 
#include "GeneratorObjects/xAODTruthParticleLink.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODEgamma/Electron.h"
#include "xAODEgamma/ElectronContainer.h"
#include "xAODEgamma/EgammaTruthxAODHelpers.h"
 
#include "TrackVertexAssociationTool/TrackVertexAssociationTool.h"
#include "xAODEventInfo/EventInfo.h"
 
#include <map>
#include <string>
#include "TH1.h"
#include "TH2.h"
 
#include "AthenaBaseComps/AthAlgorithm.h"
 
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
#include "TrkExInterfaces/IExtrapolator.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "BeamSpotConditionsData/BeamSpotData.h"
 
#include "TrigDecisionTool/TrigDecisionTool.h"
#include "TriggerMatchingTool/IMatchingTool.h" 
 
 
 
 
class IegammaTrkRefitterTool;
 
namespace Trig{
  class TrigDecisionTool;
  class MatchingTool;
}
 
namespace TrigConf {
  class xAODConfigTool;
}
 
namespace Trk{
  class ITrackToVertexIPEstimator;
  class IExtrapolator;
}
 
 
namespace InDet {
  class IInDetTrackSelectionTool;
}
 
namespace CP { class ITrackVertexAssociationTool;}
 
class IDPerfMonZmumu : public AthAlgorithm
{
 public:
  // Constructors & destructors
 
  IDPerfMonZmumu(const std::string& name, ISvcLocator* pSvcLocator);
 
  ~IDPerfMonZmumu();
 
  // Overriden class functions.
  virtual StatusCode initialize();
  virtual StatusCode execute(const EventContext& ctx);
  virtual StatusCode finalize();
 
 protected:
 
 private:
  // Private class 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, const EventContext& ctx);
  StatusCode          FillRecParametersTP (const xAOD::TrackParticle* trackp, const xAOD::TrackParticle* trackp_for_unbias, double charge, const xAOD::Vertex* vertex, const EventContext& ctx);
  StatusCode          FillTruthParameters (const xAOD::TrackParticle* track, const EventContext& ctx);
  const xAOD::TruthParticle* getTruthParticle( const xAOD::IParticle& p );
  StatusCode          RunFourLeptonAnalysis ();
 
  // The Z0 tagger.
  ZmumuEvent     m_xZmm;
  FourMuonEvent  m_4mu;
  bool m_UseTrigger{true};
  bool m_doIsoSelection{true};
  bool m_doIPSelection{true};
  bool m_doMCPSelection{true};
  double m_MassWindowLow{60.};
  double m_MassWindowHigh{120.};
  double m_LeadingMuonPtCut{20.};
  double m_SecondMuonPtCut{15.};
  double m_OpeningAngleCut{0.2};
  double m_Z0GapCut{5.};
  bool m_isMC{};
  bool m_doRefit{};
  bool m_useTrackSelectionTool{};
  bool m_doIP{};
  bool m_doFourMuAnalysis{};
  bool m_storeZmumuNtuple{true};
  bool m_skipMS{};
  bool m_useCustomMuonSelector{};
  int  m_minGoodLumiBlock{};
  int  m_maxGoodLumiBlock{};
 

  ToolHandle<IegammaTrkRefitterTool>  m_TrackRefitter1;

  ToolHandle<IegammaTrkRefitterTool>  m_TrackRefitter2;

  ToolHandle<Reco::ITrackToVertex> m_trackToVertexTool;
 
  /* /\** @brief The trigger decision tool *\/ */
  ToolHandle<Trig::TrigDecisionTool> m_triggerDecision; 
 
 
  /* /\** @brief The trigger decision tool *\/ */
  ToolHandle<Trig::IMatchingTool> m_triggerMatching; 

  ToolHandle< InDet::IInDetTrackSelectionTool > m_selTool;
 

  ToolHandle< Trk::ITrackToVertexIPEstimator > m_trackToVertexIPEstimator;

  SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
  ToolHandle<Trk::IExtrapolator> m_extrapolator;

  ToolHandle<CP::IMuonSelectionTool> m_muonSelector; 
 
  //Validation Ntuple variables
  bool                            m_validationMode;

  std::string                     m_commonTreeName;        //Tree containing all track collections
  std::string                     m_defaultTreeName;       //Default Tracks
  std::string                     m_IDTreeName;            //Default ID Tracks
  std::string                     m_refit1TreeName;        //Refit ID Tracks
  std::string                     m_refit2TreeName;        //Refit ID Tracks
  std::string                     m_truthTreeName;         //Truth Tracks
  std::string                     m_combTreeName;          //Combined Staco
  std::string                     m_MSTreeName;            //MS tracks
  std::string                     m_FourMuTreeName;        //Four lepton tree
 
 

  std::string                     m_ValidationTreeDescription;

  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;

  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;
 
  /* vertex */
  SG::ReadHandleKey<xAOD::VertexContainer> m_vertexKey { this, "VertexContainer", "PrimaryVertices", "primary vertex container" };
  
  SG::ReadHandleKey<xAOD::TrackParticleContainer> m_trackContainerName{this, "trackContainerName", "InDetTrackParticles"};
 
 
  std::string m_truthName;          
  std::string m_trackParticleName;  
  std::string m_truthLinkVecName;   
 
  // cut flow histogram
  TH1F*                           m_h_cutflow{};
 
  unsigned int  m_runNumber{};
  unsigned int  m_evtNumber{};
  unsigned int  m_lumi_block{};
  unsigned int  m_event_mu{};
  float         m_event_weight{};
  int           m_triggerPrescale{};
  std::string m_triggerName;
  unsigned int  m_nVertex{};
  float         m_beamposX{};
  float         m_beamposY{};
 
  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_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_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{};
 
  // electrons in four leptons analysis
  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{};
 
  // common tree
  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;
 
  // needed to handle EventInfo now.. 2/8/21 (prob. rel.22)
  SG::ReadHandleKey<xAOD::EventInfo> m_EventInfoKey{this, "EventInfoKey", "EventInfo"};
};
//==============================================================================
 
#endif