From 8cad172eb4a2b687ffcfc8f248f21ddb9321ded8 Mon Sep 17 00:00:00 2001
From: Marcello Barisonzi <marcello.barisonzi@cern.ch>
Date: Fri, 23 May 2014 18:04:17 +0200
Subject: [PATCH] See ChangeLog (JetTagMonitoring-00-04-06)
---
.../JetTagMonitoring/JetTagMonitoring.h | 400 ++++++
.../JetTagMonitoring/cmt/requirements | 54 +
.../config/jetTag_collisions_run.config | 75 +
.../share/JetTagMonitoring_jobOptions.py | 58 +
.../JetTagMonitoring/share/JetTagging_test.cc | 523 +++++++
.../JetTagMonitoring/share/JetTagging_test.py | 174 +++
.../JetTagMonitoring/share/switchMon.py | 47 +
.../JetTagMonitoring/src/JetTagMonitoring.cxx | 1201 +++++++++++++++++
.../components/JetTagMonitoring_entries.cxx | 10 +
.../src/components/JetTagMonitoring_load.cxx | 3 +
10 files changed, 2545 insertions(+)
create mode 100755 PhysicsAnalysis/JetTagging/JetTagMonitoring/JetTagMonitoring/JetTagMonitoring.h
create mode 100755 PhysicsAnalysis/JetTagging/JetTagMonitoring/cmt/requirements
create mode 100644 PhysicsAnalysis/JetTagging/JetTagMonitoring/config/jetTag_collisions_run.config
create mode 100644 PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagMonitoring_jobOptions.py
create mode 100644 PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagging_test.cc
create mode 100644 PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagging_test.py
create mode 100644 PhysicsAnalysis/JetTagging/JetTagMonitoring/share/switchMon.py
create mode 100755 PhysicsAnalysis/JetTagging/JetTagMonitoring/src/JetTagMonitoring.cxx
create mode 100755 PhysicsAnalysis/JetTagging/JetTagMonitoring/src/components/JetTagMonitoring_entries.cxx
create mode 100755 PhysicsAnalysis/JetTagging/JetTagMonitoring/src/components/JetTagMonitoring_load.cxx
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/JetTagMonitoring/JetTagMonitoring.h b/PhysicsAnalysis/JetTagging/JetTagMonitoring/JetTagMonitoring/JetTagMonitoring.h
new file mode 100755
index 00000000000..1c313291994
--- /dev/null
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/JetTagMonitoring/JetTagMonitoring.h
@@ -0,0 +1,400 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// *******************************************************
+//
+// NAME: JetTagMonitoring.h
+// PACKAGE: PhysicsAnalysis/JetTagging/JetTagMonitoring
+//
+// AUTHOR: Andrea Coccaro
+// EMAIL: Andrea.Coccaro@ge.infn.it
+//
+// *******************************************************
+
+#ifndef JETTAGMONITORING_H
+#define JETTAGMONITORING_H
+
+#include <vector>
+#include <string>
+#include <bitset>
+
+#include <map>
+#include "GaudiKernel/ServiceHandle.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "ITrackToVertex/ITrackToVertex.h"
+#include "AthenaMonitoring/ManagedMonitorToolBase.h"
+
+#include "InDetConditionsSummaryService/IInDetConditionsSvc.h"
+
+#include "xAODJet/Jet.h"
+
+class TH1F_LW;
+class TH2F_LW;
+class StoreGateSvc;
+class RunSummary;
+class LWHist;
+
+namespace Trk {
+ class VxCandidate;
+}
+namespace Analysis {
+ class TrackSelector;
+}
+
+/**
+ * @brief Class for monitoring variables related to offline flavour tagging.
+ *
+ * @author Andrea Coccaro <Andrea.Coccaro@ge.infn.it>
+ *
+ * This class answers monitoring needs related to offline flavour tagging:
+ *
+ * - btagging variables;
+ * - jet/tracks related variables;
+ * - muon/electron related variables;
+ * - global variables of interest for flavour tagging.
+ */
+
+
+class JetTagMonitoring : public ManagedMonitorToolBase {
+
+ friend class RunSummary;
+
+public:
+
+ JetTagMonitoring(const std::string & type, const std::string & name, const IInterface* parent);
+
+ ~JetTagMonitoring();
+
+ virtual StatusCode initialize();
+
+ virtual StatusCode bookHistograms();
+ virtual StatusCode fillHistograms();
+ virtual StatusCode procHistograms( );
+
+
+private:
+
+ enum Jet_t { goodJet, badJet, suspectJet };
+
+ virtual StatusCode registerHist (MonGroup& theGroup, TH1* h1);
+ virtual StatusCode registerHist (MonGroup& theGroup, LWHist* h1);
+
+ bool applyKinematicCuts(const xAOD::Jet *jet);
+ Jet_t applyQualityCuts(const xAOD::Jet *jet);
+
+ void fillJetHistograms();
+ void fillGoodJetHistos(const xAOD::Jet *jet);
+ //void fillSuspectJetHistos(const xAOD::Jet *jet);
+ void fillDetailedHistograms(const xAOD::Jet *jet);
+ //void fillElectronHistograms(const xAOD::Jet *jet);
+ //void fillMuonHistograms(const xAOD::Jet *jet);
+ void fillTrackInJetHistograms(const xAOD::Jet *jet);
+ void fillBadTrackBits(const std::bitset<16> failedCuts, double eta, double phi);
+ //void fillBadZone(int zone, double w);
+ bool isGoodJet(const xAOD::Jet *jet);
+
+ ServiceHandle<StoreGateSvc> m_storeGate;
+
+
+ ToolHandle< Analysis::TrackSelector > m_trackSelectorTool;
+ ToolHandle<Reco::ITrackToVertex> m_trackToVertexTool;
+ /* ToolHandle<InDet::IInDetTestBLayerTool> m_blayerTool; */
+ bool m_histogramsCreated;
+
+ const Trk::VxCandidate* m_priVtx;
+
+ /** @brief String to retrieve JetContainer from StoreGate. */
+ std::string m_jetName;
+ /** @brief String to retrieve TrackParticleContainer from StoreGate. */
+ std::string m_trackParticleName;
+ /** @brief String to retrieve PrimaryVertexContainer from StoreGate. */
+ std::string m_primaryVertexName;
+ /** @brief DQ cuts switcher. */
+ bool m_do_cuts;
+ double m_trk_d0_min_cut;
+ double m_trk_d0_max_cut;
+ unsigned int m_pri_vtx_trk_min_cut;
+ double m_jet_pt_cut;
+ double m_jet_eta_cut;
+ unsigned int m_trk_n;
+ double m_sv0_weight_cut;
+ double m_sv1_weight_cut;
+ double m_sv2_weight_cut;
+
+ double m_ip1d_weight_cut;
+ double m_ip2d_weight_cut;
+ double m_ip3d_weight_cut;
+
+ double m_sv1ip3d_weight_cut;
+ double m_jfcnn_weight_cut;
+
+ /* From the twiki: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/TopCommonObjects#B_tagging
+ * As a starting point we recommend to use the 70% working point (also for the acceptance and yields challenges)
+ * This corresponds to a cut at: weight > 0.601713 */
+ double m_mv1_weight_cut;
+
+ /** @brief Master kill if no tools found. */
+ bool m_switch_off;
+
+ /** @brief Use Analysis::TrackSelector. */
+ bool m_use_trackselector;
+
+ /** @brief Use Analysis::TrigDecisionTool. */
+ bool m_use_trigdectool;
+
+
+ /** @brief To monitor likelihood weight based on transverse impact parameter. */
+ TH1F_LW* m_tag_ip1d_w;
+ /** @brief To monitor likelihood weight based on longitudinal impact parameter. */
+ TH1F_LW* m_tag_ip2d_w;
+ /** @brief To monitor number of tracks used to evaluate IP2D weight. */
+ TH1F_LW* m_tag_ip2d_n;
+ /** @brief To monitor jet likelihood value if coming from b decay for IP2D tagger. */
+ TH1F_LW* m_tag_ip2d_b;
+ /** @brief To monitor jet likelihood value if coming from u decay for IP2D tagger. */
+ TH1F_LW* m_tag_ip2d_u;
+ /** @brief To monitor likelihood weight based on combination of impact parameters. */
+ TH1F_LW* m_tag_ip3d_w;
+ /** @brief To monitor number of tracks used to evaluate IP3D weight. */
+ TH1F_LW* m_tag_ip3d_n;
+ /** @brief To monitor jet likelihood value if coming from b decay for IP3D tagger. */
+ TH1F_LW* m_tag_ip3d_b;
+ /** @brief To monitor jet likelihood value if coming from u decay for IP3D tagger. */
+ TH1F_LW* m_tag_ip3d_u;
+ /** @brief To monitor likelihood weight based on SV0 tagger. */
+ TH1F_LW* m_tag_sv0_w;
+ /** @brief To monitor likelihood weight based on SV1 tagger. */
+ TH1F_LW* m_tag_sv1_w;
+ /** @brief To monitor likelihood weight based on SV2 tagger. */
+ TH1F_LW* m_tag_sv2_w;
+ /** @brief To monitor likelihood weight based on LF2D tagger. */
+ TH1F_LW* m_tag_lf2d_w;
+ /** @brief To monitor likelihood weight based on SVBU tagger. */
+ TH1F_LW* m_tag_svbu_w;
+ /** @brief To monitor likelihood weight based on LHSIG tagger. */
+ TH1F_LW* m_tag_lhsig_w;
+ /** @brief To monitor likelihood weight based on SOFTM tagger. */
+ TH1F_LW* m_tag_softm_w;
+ /** @brief To monitor likelihood weight based on SOFTE tagger. */
+ TH1F_LW* m_tag_softe_w;
+ /** @brief To monitor likelihood weight based on combined tagger (IP3D+SV1). */
+ TH1F_LW* m_tag_comb_w;
+ /** @brief To monitor likelihood weight based on combined tagger JetFitterCOMBNN. */
+ TH1F_LW* m_tag_jfcnn_w;
+ /** @brief To monitor likelihood weight based on combined tagger MV1 (based on IP3D tagging weight, SV1 tagging weight,
+ * JetFitterCombNN tagging weight, jet pT (in MeV) and jet eta.).
+ */
+ TH1F_LW* m_tag_mv1_w;
+ /*
+ TH1F_LW* m_tag_sv0_w_sj;
+ TH1F_LW* m_tag_comb_w_sj;
+ TH1F_LW* m_tag_jfcnn_w_sj;
+
+ TH1F_LW* m_tag_sv0_w_DMZ1;
+ TH1F_LW* m_tag_comb_w_DMZ1;
+ TH1F_LW* m_tag_jfcnn_w_DMZ1;
+ TH1F_LW* m_tag_ip3d_w_DMZ1;
+
+ TH1F_LW* m_tag_sv0_w_DMZ2;
+ TH1F_LW* m_tag_comb_w_DMZ2;
+ TH1F_LW* m_tag_jfcnn_w_DMZ2;
+ TH1F_LW* m_tag_ip3d_w_DMZ2;
+
+ TH1F_LW* m_tag_sv0_w_DMZ3;
+ TH1F_LW* m_tag_comb_w_DMZ3;
+ TH1F_LW* m_tag_jfcnn_w_DMZ3;
+ TH1F_LW* m_tag_ip3d_w_DMZ3;
+
+ TH1F_LW* m_tag_ip3d_w_DMZ2_x1;
+ TH1F_LW* m_tag_ip3d_w_DMZ2_x2;
+ TH1F_LW* m_tag_ip3d_w_DMZ2_x4;
+ TH1F_LW* m_tag_ip3d_w_DMZ2_x8;
+
+ TH1F_LW* m_tag_ip3d_w_DMZ3_x1;
+ TH1F_LW* m_tag_ip3d_w_DMZ3_x2;
+ TH1F_LW* m_tag_ip3d_w_DMZ3_x4;
+ TH1F_LW* m_tag_ip3d_w_DMZ3_x8;
+ */
+
+ /** @brief To monitor likelihood weight based on TrackCounting tagger. */
+ TH1F_LW* m_tag_trkcnt_w;
+ /** @brief To monitor likelihood weight based on JetProb tagger. */
+ TH1F_LW* m_tag_jetprob_w;
+
+ /** @brief To monitor number of Jets. */
+ TH1F_LW* m_jet_n;
+ /** @brief To monitor number of TrackParticles. */
+ TH1F_LW* m_trackParticle_n;
+
+ /** @brief To monitor number of primary vertices. */
+ TH1F_LW* m_global_nPrimVtx;
+ /** @brief To monitor x of primary vertex. */
+ TH1F_LW* m_global_xPrimVtx;
+ /** @brief To monitor y of primary vertex. */
+ TH1F_LW* m_global_yPrimVtx;
+ /** @brief To monitor z of primary vertex. */
+ TH1F_LW* m_global_zPrimVtx;
+
+ /** @brief To monitor number of b layer hits in TrackParticle. */
+ TH1F_LW* m_global_BLayerHits;
+ /** @brief To monitor number of pixel hits in TrackParticle. */
+ TH1F_LW* m_global_PixelHits;
+ /** @brief To monitor number of SCT hits in TrackParticle. */
+ TH1F_LW* m_global_SCTHits;
+ /** @brief To monitor number of pixel+SCT hits in TrackParticle. */
+ TH1F_LW* m_global_SiHits;
+ /** @brief To monitor number of TRT hits in TrackParticle. */
+ TH1F_LW* m_global_TRTHits;
+
+ /** @brief To monitor number of tags of the reconstructed jet. */
+ TH1F_LW* m_jet_nTag;
+ /** @brief To monitor eta of the reconstructed jet. */
+ TH1F_LW* m_jet_eta;
+ /** @brief To monitor phi of the reconstructed jet. */
+ TH1F_LW* m_jet_phi;
+ /** @brief To monitor Et of the reconstructed jet. */
+ TH1F_LW* m_jet_et;
+
+ /** @brief To monitor number of tracks in a jet. */
+ TH1F_LW* m_jet_tracks_n;
+ /** @brief To monitor Pt of tracks in a jet. */
+ TH1F_LW* m_jet_tracks_pt;
+ /** @brief To monitor eta of tracks in a jet. */
+ TH1F_LW* m_jet_tracks_eta;
+ /** @brief To monitor phi of tracks in a jet. */
+ TH1F_LW* m_jet_tracks_phi;
+ /** @brief To monitor number of b layer hits in a jet. */
+ TH1F_LW* m_jet_tracks_BLayerHits;
+ /** @brief To monitor number of pixel hits in a jet. */
+ TH1F_LW* m_jet_tracks_PixelHits;
+ /** @brief To monitor number of SCT hits in a jet. */
+ TH1F_LW* m_jet_tracks_SCTHits;
+ /** @brief To monitor number of muons in a jet. */
+ TH1F_LW* m_jet_muons_n;
+ /** @brief To monitor Pt of muons in a jet. */
+ TH1F_LW* m_jet_muons_pt;
+
+ //* electron variables per jet *//
+ /** @brief To monitor number of electrons in a jet. */
+ TH1F_LW* m_jet_electrons_n;
+ /** @brief To monitor Pt of electrons in a jet. */
+ TH1F_LW* m_jet_electrons_pt;
+
+ TH1F_LW* m_trigPassed;
+ TH1F_LW* m_cutflow;
+
+ TH1F_LW* m_cutflow_jet;
+
+ TH2F_LW* m_priVtx_trks;
+
+ /** @brief 2D map of track selector efficiency. */
+ TH2F_LW* m_track_selector_eff;
+ TH2F_LW* m_track_selector_eff_LS;
+ //TH2F_LW* m_track_selector_suspect;
+ TH2F_LW* m_track_selector_all;
+ TH2F_LW* m_track_selector_all_LS;
+
+ /** @brief 2D map of jets at various cuts. */
+ TH2F_LW* m_jet_2D_all;
+ TH2F_LW* m_jet_2D_good;
+ TH2F_LW* m_jet_2D_kinematic;
+ TH2F_LW* m_jet_2D_kinematic_LS;
+ TH2F_LW* m_jet_2D_quality;
+ //TH2F_LW* m_jet_2D_suspect;
+
+ /** @brief 2D map of tag rates. */
+ TH2F_LW* m_sv0_tag_pos_rate_2D;
+ TH2F_LW* m_sv0_tag_neg_rate_2D;
+ TH2F_LW* m_sv1_tag_pos_rate_2D;
+ TH2F_LW* m_sv1_tag_neg_rate_2D;
+ TH2F_LW* m_sv2_tag_pos_rate_2D;
+ TH2F_LW* m_sv2_tag_neg_rate_2D;
+
+ TH2F_LW* m_ip1d_tag_pos_rate_2D;
+ TH2F_LW* m_ip1d_tag_neg_rate_2D;
+ TH2F_LW* m_ip2d_tag_pos_rate_2D;
+ TH2F_LW* m_ip2d_tag_neg_rate_2D;
+ TH2F_LW* m_ip3d_tag_pos_rate_2D;
+ TH2F_LW* m_ip3d_tag_neg_rate_2D;
+ TH2F_LW* m_ip3d_tag_def_rate_2D;
+ TH2F_LW* m_ip3d_tag_def_rate_2D_LS;
+
+ TH2F_LW* m_sv1ip3d_tag_pos_rate_2D;
+ TH2F_LW* m_sv1ip3d_tag_neg_rate_2D;
+
+ TH2F_LW* m_jfcnn_tag_pos_rate_2D;
+ TH2F_LW* m_jfcnn_tag_neg_rate_2D;
+
+ enum Cuts_t { pTMin, d0Max, z0Max, sigd0Max, sigz0Max, etaMax,
+ nHitBLayer, deadBLayer, nHitPix, nHitSct, nHitSi, nHitTrt, nHitTrtHighE,
+ fitChi2, fitProb, fitChi2OnNdfMax, numCuts
+ };
+
+ /** @brief
+ * 2D map of MV1 tag rate
+ */
+ TH2F_LW* m_mv1_tag_pos_rate_2D;
+ TH2F_LW* m_mv1_tag_neg_rate_2D;
+ TH2F_LW* m_mv1_tag_def_rate_2D;
+ TH2F_LW* m_mv1_tag_def_rate_2D_LS;
+
+
+ /** @brief 2D map of TrackSelectorTool cuts */
+ TH2F_LW* m_tracks_all_2D;
+ TH2F_LW* m_tracks_pTMin_2D;
+ TH2F_LW* m_tracks_d0Max_2D;
+ TH2F_LW* m_tracks_z0Max_2D;
+ TH2F_LW* m_tracks_sigd0Max_2D;
+ TH2F_LW* m_tracks_sigz0Max_2D;
+ TH2F_LW* m_tracks_etaMax_2D;
+ TH2F_LW* m_tracks_nHitBLayer_2D;
+ TH2F_LW* m_tracks_deadBLayer_2D;
+ TH2F_LW* m_tracks_nHitPix_2D;
+ TH2F_LW* m_tracks_nHitSct_2D;
+ TH2F_LW* m_tracks_nHitSi_2D;
+ TH2F_LW* m_tracks_nHitTrt_2D;
+ TH2F_LW* m_tracks_nHitTrtHighE_2D;
+ TH2F_LW* m_tracks_fitChi2_2D;
+ TH2F_LW* m_tracks_fitProb_2D;
+ TH2F_LW* m_tracks_fitChi2OnNdfMax_2D;
+
+ TH2F_LW* m_tracks_all_2D_LS;
+ TH2F_LW* m_tracks_pTMin_2D_LS;
+ TH2F_LW* m_tracks_d0Max_2D_LS;
+ TH2F_LW* m_tracks_z0Max_2D_LS;
+ TH2F_LW* m_tracks_sigd0Max_2D_LS;
+ TH2F_LW* m_tracks_sigz0Max_2D_LS;
+ TH2F_LW* m_tracks_etaMax_2D_LS;
+ TH2F_LW* m_tracks_nHitBLayer_2D_LS;
+ TH2F_LW* m_tracks_deadBLayer_2D_LS;
+ TH2F_LW* m_tracks_nHitPix_2D_LS;
+ TH2F_LW* m_tracks_nHitSct_2D_LS;
+ TH2F_LW* m_tracks_nHitSi_2D_LS;
+ TH2F_LW* m_tracks_nHitTrt_2D_LS;
+ TH2F_LW* m_tracks_nHitTrtHighE_2D_LS;
+ TH2F_LW* m_tracks_fitChi2_2D_LS;
+ TH2F_LW* m_tracks_fitProb_2D_LS;
+ TH2F_LW* m_tracks_fitChi2OnNdfMax_2D_LS;
+
+ TH1F_LW* m_efficiency;
+
+ unsigned int m_lumiBlockNum;
+
+ MonGroup* m_monGr_shift;
+ MonGroup* m_monGr_LowStat;
+
+ //--------------Pixel stuff--------------------------------------
+ ServiceHandle <IInDetConditionsSvc> m_pixelCondSummarySvc;
+
+ bool m_doModules;
+ bool m_doOffline;
+ bool m_isNewLumiBlock;
+ bool m_doLumiBlock;
+ bool m_majorityDisabled;
+ bool m_doStatus;
+
+};
+
+#endif
+
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/cmt/requirements b/PhysicsAnalysis/JetTagging/JetTagMonitoring/cmt/requirements
new file mode 100755
index 00000000000..b48f10579c4
--- /dev/null
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/cmt/requirements
@@ -0,0 +1,54 @@
+package JetTagMonitoring
+
+author Andrea Coccaro <Andrea.Coccaro@ge.infn.it>
+
+
+# ============================================================================================
+public
+
+use AtlasPolicy AtlasPolicy-*
+use GaudiInterface GaudiInterface-* External
+use AthenaMonitoring AthenaMonitoring-* Control
+
+
+# ============================================================================================
+private
+
+use AtlasROOT AtlasROOT-* External
+use JetTagTools JetTagTools-* PhysicsAnalysis/JetTagging
+use xAODEventInfo xAODEventInfo-* Event/xAOD
+use xAODTracking xAODTracking-* Event/xAOD
+use xAODBTagging xAODBTagging-* Event/xAOD
+
+use TrigDecisionTool TrigDecisionTool-* Trigger/TrigAnalysis
+use GaudiInterface GaudiInterface-* External
+
+use TrkVertexFitterInterfaces TrkVertexFitterInterfaces-* Tracking/TrkVertexFitter
+use TrkParticleBase TrkParticleBase-* Tracking/TrkEvent
+use VxSecVertex VxSecVertex-* Tracking/TrkEvent
+
+use LArRecEvent LArRecEvent-* LArCalorimeter
+
+use LWHists LWHists-* Tools
+
+# ============================================================================================
+public
+
+use xAODJet xAODJet-* Event/xAOD
+use ITrackToVertex ITrackToVertex-* Reconstruction/RecoTools
+use InDetConditionsSummaryService InDetConditionsSummaryService* InnerDetector/InDetConditions
+
+
+library JetTagMonitoring *.cxx components/*.cxx
+
+apply_pattern component_library
+apply_pattern declare_joboptions files="*.py"
+apply_pattern declare_python_modules files="*.py"
+
+
+
+
+
+
+
+
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/config/jetTag_collisions_run.config b/PhysicsAnalysis/JetTagging/JetTagMonitoring/config/jetTag_collisions_run.config
new file mode 100644
index 00000000000..503cfe6ea9c
--- /dev/null
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/config/jetTag_collisions_run.config
@@ -0,0 +1,75 @@
+# **********************************************************************
+# $Id: jetTag_collisions_run.config,v 1.1 2008-09-03 14:00:56 mgwilson Exp $
+# **********************************************************************
+
+
+#######################
+# References
+#######################
+
+reference JetTagShiftHists_Ref {
+ file = /afs/cern.ch/user/a/atlasdqm/dqmdisk/tier0/han_references/Collisions/MonitorESD_run52300_BTagging_080902.SHIFT.root
+ path = run_52300
+ name = same_name
+}
+
+reference JetTagOverlay_Ref {
+ file = /afs/cern.ch/user/a/atlasdqm/dqmdisk/tier0/han_references/Collisions/MonitorESD_run52300_BTagging_080902.root
+ path = run_52300
+ name = same_name
+}
+
+
+####################
+# Common Algorithms
+####################
+
+algorithm WorstCaseSummary {
+ libname = libdqm_summaries.so
+ name = WorstCaseSummary
+}
+
+compositeAlgorithm Histogram_Not_Empty&GatherData {
+ subalgs = GatherData,Histogram_Not_Empty
+ libnames = libDataQualityInterfacesAlgs.so,libdqm_algorithms.so
+}
+
+
+#############
+# Output
+#############
+
+output top_level {
+ algorithm = WorstCaseSummary
+
+ output JetTagging {
+
+ }
+}
+
+
+############################################################
+# Jet Tagging
+############################################################
+
+#######################
+# Histogram Assessments
+#######################
+
+dir JetTagging {
+ reference = JetTagShiftHists_Ref
+ algorithm = JetTag_GatherData
+ output = JetTagging
+ hist all_in_dir {
+ }
+}
+
+###########################
+# Algorithms and Thresholds
+###########################
+
+algorithm JetTag_GatherData {
+ name = Histogram_Not_Empty&GatherData
+ #reference = JetTagOverlay_Ref
+}
+
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagMonitoring_jobOptions.py b/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagMonitoring_jobOptions.py
new file mode 100644
index 00000000000..547e6bd4e87
--- /dev/null
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagMonitoring_jobOptions.py
@@ -0,0 +1,58 @@
+
+monManJetTag = AthenaMonManager(name="JetTagMonManager",
+ FileKey = DQMonFlags.monManFileKey(),
+ Environment = DQMonFlags.monManEnvironment(),
+ ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup(),
+ DataType = DQMonFlags.monManDataType())
+topSequence += monManJetTag
+
+from JetTagMonitoring.JetTagMonitoringConf import JetTagMonitoring
+jetTagMonTool = JetTagMonitoring (
+ name = "jetTagMonTool",
+ )
+ToolSvc += jetTagMonTool
+monManJetTag.AthenaMonTools += [ jetTagMonTool ]
+
+# remove events with non-collision BCIDs from your monitoring tools
+# see https://indico.cern.ch/getFile.py/access?contribId=1&resId=1&materialId=slides&confId=135968
+jetTagMonTool.FilterTools += [ monFilledBunchFilterTool ]
+
+# remove events with intolerable LAr defects
+from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
+monbadlb = GetLArBadLBFilterTool()
+jetTagMonTool.FilterTools += [ monbadlb ]
+
+jetTagMonTool.OutputLevel = INFO
+jetTagMonTool.JetContainer = "AntiKt4TopoEMJets"
+jetTagMonTool.DQcuts = True
+jetTagMonTool.PriVtxTrkMinCut = 4
+jetTagMonTool.D0_min_cuts = 0
+jetTagMonTool.D0_max_cuts = 1
+jetTagMonTool.JetPt_cuts = 15000
+jetTagMonTool.JetEta_cuts = 2.5
+jetTagMonTool.nTrk_cuts = 1
+
+##### EPS recommendations
+##### https://twiki.cern.ch/twiki/bin/view/AtlasProtected/Analysis16#Calibrations_to_be_used_for_EPS
+
+jetTagMonTool.SV0_weight_cut = 5.85
+jetTagMonTool.SV1IP3D_weight_cut = 4.5
+jetTagMonTool.JetFitterCOMBNN_weight_cut = 2.0
+#jetTagMonTool.MV1_weight_cut = 0.601713
+jetTagMonTool.MV1_weight_cut = 0.601713
+jetTagMonTool.IP3D_weight_cut = 3.75
+
+if not rec.doInDet:
+ jetTagMonTool.UseTrackSelector = False
+else:
+ jetTagMonTool.UseTrackSelector = True
+
+if DQMonFlags.useTrigger() and hasattr(ToolSvc, DQMonFlags.nameTrigDecTool()):
+ print "jetTagMonTool will use TrigDecisionTool instance: %s" % DQMonFlags.nameTrigDecTool()
+ jetTagMonTool.TrigDecisionTool = getattr(ToolSvc, DQMonFlags.nameTrigDecTool())
+ jetTagMonTool.TriggerChain = "L1_J.*, L1_[3-5]J.* ,EF_e24vh_medium1, EF_mu18_IDTrkNoCut_tight, L1_RD0_FILLED" #"L1_J10" even older #"EF_mu4_L1J10_matched"
+ jetTagMonTool.UseTrigDecisionTool = True
+else:
+ print "WARNING!!! jetTagMonTool will NOT use TrigDecisionTool."
+ jetTagMonTool.UseTrigDecisionTool = False
+
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagging_test.cc b/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagging_test.cc
new file mode 100644
index 00000000000..4d2e98670ea
--- /dev/null
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagging_test.cc
@@ -0,0 +1,523 @@
+#include "TCanvas.h"
+#include "TGraph.h"
+#include "TLegend.h"
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TROOT.h"
+#include "TTree.h"
+#include "TFile.h"
+#include <iostream>
+#include <string>
+void JetTagging_test()
+{
+//---------------------insert HIST filename here---------------------------
+string HISTfile = "/tmp/mbarison/data11_7TeV.00186493.physics_JetTauEtmiss.merge.HIST.f393_m926/data11_7TeV.00186493.physics_JetTauEtmiss.merge.HIST.f393_m926._0001.1";
+//---------------------------------------------------------------------------
+ gStyle->SetPalette(1);
+ using std;
+ double P[16];
+ double Summ[16];
+ double Summ1[16];
+ double Summ2[16];
+ double Max[16];
+ double Max1[16];
+ double Max2[16];
+ string MonFile = "root://castoratlas//castor/cern.ch/grid/atlas/caf/atlcal/perm/dataqual/han_references/Collisions/data11_7TeV.00183347.express_express.merge.HIST.f384_m875._0001.1.root";
+
+
+ string run;
+ TFile* BTagMonteCarlo= TFile::Open(MonFile.c_str());
+ TFile* BTagExp= TFile::Open(HISTfile.c_str());
+
+ size_t a;
+ a=HISTfile.find(".00");
+ run=HISTfile.substr(a+3,6);
+
+ printf ("================== Analysing Run %s ==================\n", run.c_str());
+
+ BTagMonteCarlo->cd();
+ TH1F* m_jet_electrons_n = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/jet_electrons_n");
+ TH1F* m_jet_muons_n = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/jet_muons_n");
+ TH1F* m_jet_tracks_hits_BLayer = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/jet_tracks_hits_BLayer");
+ TH1F* m_jet_tracks_hits_Pixel = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/jet_tracks_hits_Pixel");
+ TH1F* m_jet_tracks_hits_SCT = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/jet_tracks_hits_SCT");
+ TH1F* m_jet_tracks_n = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/jet_tracks_n");
+ TH1F* m_jetProb = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/tag_JetProb_w");
+ TH1F* m_sv0 = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/tag_SV0_w");
+ TH1F* m_tag_COMB_w = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/tag_COMB_w");
+ TH1F* m_tag_IP1D_w = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/tag_IP1D_w");
+ TH1F* m_tag_IP2D_w = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/tag_IP2D_w");
+ TH1F* m_tag_IP3D_w = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/tag_IP3D_w");
+ TH1F* m_trkCnt = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/tag_TrkCnt_w");
+ TH1F* m_SOFTE = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/tag_SOFTE_w");
+ TH1F* m_SOFTM = (TH1F*)BTagMonteCarlo->Get("run_183347/JetTagging/tag_SOFTM_w");
+ TH2F* m_trackSelEff = (TH2F*)BTagMonteCarlo->Get("run_183347/JetTagging/track_selector_eff");
+ TH2F* m_trackSelAll = (TH2F*)BTagMonteCarlo->Get("run_183347/JetTagging/track_selector_all");
+
+ BTagExp->cd();
+ TH1F* ex_jet_electrons_n = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/jet_electrons_n"));
+ TH1F* ex_jet_muons_n = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/jet_muons_n"));
+ TH1F* ex_jet_tracks_hits_BLayer = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/jet_tracks_hits_BLayer"));
+ TH1F* ex_jet_tracks_hits_Pixel = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/jet_tracks_hits_Pixel"));
+ TH1F* ex_jet_tracks_hits_SCT = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/jet_tracks_hits_SCT"));
+ TH1F* ex_jet_tracks_n = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/jet_tracks_n"));
+ TH1F* ex_jetProb = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/tag_JetProb_w"));
+ TH1F* ex_sv0 = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/tag_SV0_w"));
+ TH1F* ex_tag_COMB_w = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/tag_COMB_w"));
+ TH1F* ex_tag_IP1D_w = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/tag_IP1D_w"));
+ TH1F* ex_tag_IP2D_w = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/tag_IP2D_w"));
+ TH1F* ex_tag_IP3D_w = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/tag_IP3D_w"));
+ TH1F* ex_trkCnt = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/tag_TrkCnt_w"));
+ TH1F* ex_SOFTE = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/tag_SOFTE_w"));
+ TH1F* ex_SOFTM = (TH1F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/tag_SOFTM_w"));
+ TH2F* ex_trackSelEff = (TH2F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/track_selector_eff"));
+ TH2F* ex_trackSelAll = (TH2F*)BTagExp->Get(TString("run_")+run.c_str()+TString("/JetTagging/track_selector_all"));
+
+if((m_jet_electrons_n->Integral() != 0)&&(ex_jet_electrons_n->Integral()!=0))
+ {
+ m_jet_electrons_n->Scale(1./m_jet_electrons_n->Integral());
+ ex_jet_electrons_n->Scale(1./ex_jet_electrons_n->Integral());
+ }
+ m_jet_electrons_n ->SetLineColor(kRed);
+ ex_jet_electrons_n->SetLineColor(kBlue);
+
+if((m_jet_muons_n->Integral() != 0)&&(ex_jet_muons_n->Integral()!=0))
+ {
+ m_jet_muons_n->Scale(1./m_jet_muons_n->Integral());
+ ex_jet_muons_n->Scale(1./ex_jet_muons_n->Integral());
+ }
+ m_jet_muons_n->SetLineColor(kRed);
+ ex_jet_muons_n->SetLineColor(kBlue);
+
+if((m_jet_tracks_hits_BLayer->Integral() != 0)&&(ex_jet_tracks_hits_BLayer->Integral()!=0))
+ {
+ m_jet_tracks_hits_BLayer->Scale(1./m_jet_tracks_hits_BLayer->Integral());
+ ex_jet_tracks_hits_BLayer->Scale(1./ex_jet_tracks_hits_BLayer->Integral());
+ }
+ m_jet_tracks_hits_BLayer->SetLineColor(kRed);
+ ex_jet_tracks_hits_BLayer->SetLineColor(kBlue);
+
+if((m_jet_tracks_hits_Pixel->Integral() != 0)&&(ex_jet_tracks_hits_Pixel->Integral()!=0))
+ {
+ m_jet_tracks_hits_Pixel->Scale(1./m_jet_tracks_hits_Pixel->Integral());
+ ex_jet_tracks_hits_Pixel->Scale(1./ex_jet_tracks_hits_Pixel->Integral());
+ }
+ m_jet_tracks_hits_Pixel->SetLineColor(kRed);
+ ex_jet_tracks_hits_Pixel->SetLineColor(kBlue);
+
+if((m_jet_tracks_hits_SCT->Integral() != 0)&&(ex_jet_tracks_hits_SCT->Integral()!=0))
+ {
+ m_jet_tracks_hits_SCT->Scale(1./m_jet_tracks_hits_SCT->Integral());
+ ex_jet_tracks_hits_SCT->Scale(1./ex_jet_tracks_hits_SCT->Integral());
+ }
+ m_jet_tracks_hits_SCT->SetLineColor(kRed);
+ ex_jet_tracks_hits_SCT->SetLineColor(kBlue);
+
+if((m_jet_tracks_n->Integral() != 0)&&(ex_jet_tracks_n->Integral()!=0))
+ {
+ m_jet_tracks_n->Scale(1./m_jet_tracks_n->Integral());
+ ex_jet_tracks_n->Scale(1./ex_jet_tracks_n->Integral());
+ }
+ m_jet_tracks_n->SetLineColor(kRed);
+ ex_jet_tracks_n->SetLineColor(kBlue);
+
+if((m_jetProb->Integral() != 0)&&(ex_jetProb->Integral()!=0))
+ {
+ m_jetProb->Scale(1./m_jetProb->Integral());
+ ex_jetProb->Scale(1./ex_jetProb->Integral());
+ }
+ m_jetProb->SetLineColor(kRed);
+ ex_jetProb->SetLineColor(kBlue);
+
+if((m_sv0->Integral() != 0)&&(ex_sv0->Integral()!=0))
+ {
+ m_sv0->Scale(1./m_sv0->Integral());
+ ex_sv0->Scale(1./ex_sv0->Integral());
+ }
+ m_sv0->SetLineColor(kRed);
+ ex_sv0->SetLineColor(kBlue);
+
+if((m_tag_COMB_w->Integral() != 0)&&(ex_tag_COMB_w->Integral()!=0))
+ {
+ m_tag_COMB_w->Scale(1./m_tag_COMB_w->Integral());
+ ex_tag_COMB_w->Scale(1./ex_tag_COMB_w->Integral());
+ }
+ m_tag_COMB_w->SetLineColor(kRed);
+ ex_tag_COMB_w->SetLineColor(kBlue);
+
+if((m_tag_IP1D_w->Integral() != 0)&&(ex_tag_IP1D_w->Integral()!=0))
+ {
+ m_tag_IP1D_w->Scale(1./m_tag_IP1D_w->Integral());
+ ex_tag_IP1D_w->Scale(1./ex_tag_IP1D_w->Integral());
+ }
+ m_tag_IP1D_w->SetLineColor(kRed);
+ ex_tag_IP1D_w->SetLineColor(kBlue);
+
+if((m_tag_IP2D_w->Integral() != 0)&&(ex_tag_IP2D_w->Integral()!=0))
+ {
+ m_tag_IP2D_w->Scale(1./m_tag_IP2D_w->Integral());
+ ex_tag_IP2D_w->Scale(1./ex_tag_IP2D_w->Integral());
+ }
+ m_tag_IP2D_w->SetLineColor(kRed);
+ ex_tag_IP2D_w->SetLineColor(kBlue);
+
+if((m_tag_IP3D_w->Integral() != 0)&&(ex_tag_IP3D_w->Integral()!=0))
+ {
+ m_tag_IP3D_w->Scale(1./m_tag_IP3D_w->Integral());
+ ex_tag_IP3D_w->Scale(1./ex_tag_IP3D_w->Integral());
+ }
+ m_tag_IP3D_w->SetLineColor(kRed);
+ ex_tag_IP3D_w->SetLineColor(kBlue);
+
+if((m_trkCnt->Integral() != 0)&&(ex_trkCnt->Integral()!=0))
+ {
+ m_trkCnt->Scale(1./m_trkCnt->Integral());
+ ex_trkCnt->Scale(1./ex_trkCnt->Integral());
+ }
+ m_trkCnt->SetLineColor(kRed);
+ ex_trkCnt->SetLineColor(kBlue);
+
+if((m_SOFTE->Integral() != 0)&&(ex_SOFTE->Integral()!=0))
+ {
+ m_SOFTE->Scale(1./m_SOFTE->Integral());
+ ex_SOFTE->Scale(1./ex_SOFTE->Integral());
+ }
+ m_SOFTE->SetLineColor(kRed);
+ ex_SOFTE->SetLineColor(kBlue);
+
+if((m_SOFTM->Integral() != 0)&&(ex_SOFTM->Integral()!=0))
+ {
+ m_SOFTM->Scale(1./m_SOFTM->Integral());
+ ex_SOFTM->Scale(1./ex_SOFTM->Integral());
+ }
+ m_SOFTM->SetLineColor(kRed);
+ ex_SOFTM->SetLineColor(kBlue);
+
+ //if((m_trackSelEff->Integral() != 0)&&(ex_trackSelEff->Integral()!=0))
+ // {
+ ex_trackSelEff->Divide(ex_trackSelAll);
+ //ex_trackSelEff->Scale(1./(ex_trackSelAll->Integral()));
+ // }
+ // m_trackSelEff->SetLineColor(kRed);
+ //ex_trackSelEff->SetLineColor(kBlue);
+
+
+ Max1[0]=m_jet_electrons_n->GetMaximum();
+ Max2[0]=ex_jet_electrons_n->GetMaximum();
+ Max1[1]=m_jet_muons_n->GetMaximum();
+ Max2[1]=ex_jet_muons_n->GetMaximum();
+ Max1[2]=m_jet_tracks_hits_BLayer->GetMaximum();
+ Max2[2]=ex_jet_tracks_hits_BLayer->GetMaximum();
+ Max1[3]=m_jet_tracks_hits_Pixel->GetMaximum();
+ Max2[3]=ex_jet_tracks_hits_Pixel->GetMaximum();
+ Max1[4]=m_jet_tracks_hits_SCT->GetMaximum();
+ Max2[4]=ex_jet_tracks_hits_SCT->GetMaximum();
+ Max1[5]=m_jet_tracks_n->GetMaximum();
+ Max2[5]=ex_jet_tracks_n->GetMaximum();
+ Max1[6]=m_jetProb->GetMaximum();
+ Max2[6]=ex_jetProb->GetMaximum();
+ Max1[7]=m_sv0->GetMaximum();
+ Max2[7]=ex_sv0->GetMaximum();
+ Max1[8]=m_trkCnt->GetMaximum();
+ Max2[8]=ex_trkCnt->GetMaximum();
+ Max1[9]=m_SOFTE->GetMaximum();
+ Max2[9]=ex_SOFTE->GetMaximum();
+ Max1[10]=m_SOFTM->GetMaximum();
+ Max2[10]=ex_SOFTM->GetMaximum();
+ Max1[11]=m_trackSelEff->GetMaximum();
+ Max2[11]=ex_trackSelEff->GetMaximum();
+ Max1[12]=m_tag_COMB_w->GetMaximum();
+ Max2[12]=ex_tag_COMB_w->GetMaximum();
+ Max1[13]=m_tag_IP1D_w->GetMaximum();
+ Max2[13]=ex_tag_IP1D_w->GetMaximum();
+ Max1[14]=m_tag_IP2D_w->GetMaximum();
+ Max2[14]=ex_tag_IP2D_w->GetMaximum();
+ Max1[15]=m_tag_IP3D_w->GetMaximum();
+ Max2[15]=ex_tag_IP3D_w->GetMaximum();
+ Summ1[0]= m_jet_electrons_n->GetEntries();
+ Summ2[0]= ex_jet_electrons_n->GetEntries();
+ for(int i=0;i<14;i++)
+ {
+ if (Max2[i]>Max1[i])
+ {
+ Max[i]=Max2[i];
+ Summ[i]=Summ2[i];
+ }
+ else
+ {
+ Max[i]=Max1[i];
+ Summ[i]=Summ1[i];
+ }
+ }
+ P[0]=m_jet_electrons_n->KolmogorovTest(ex_jet_electrons_n,"M");
+ P[1]=m_jet_muons_n->KolmogorovTest(ex_jet_muons_n,"M");
+ P[2]=m_jet_tracks_hits_BLayer->KolmogorovTest(ex_jet_tracks_hits_BLayer,"M");
+ P[3]=m_jet_tracks_hits_Pixel->KolmogorovTest(ex_jet_tracks_hits_Pixel,"M");
+ P[4]=m_jet_tracks_hits_SCT->KolmogorovTest(ex_jet_tracks_hits_SCT,"M");
+ P[5]=m_jet_tracks_n->KolmogorovTest(ex_jet_tracks_n,"M");
+ P[6]=m_jetProb->KolmogorovTest(ex_jetProb,"M");
+ P[7]=m_sv0->KolmogorovTest(ex_sv0,"M");
+ P[8]=m_trkCnt->KolmogorovTest(ex_trkCnt,"M");
+ P[9]=m_SOFTE->KolmogorovTest(ex_SOFTE,"M");
+ P[10]=m_SOFTM->KolmogorovTest(ex_SOFTM,"M");
+ P[11]=m_trackSelEff->KolmogorovTest(ex_trackSelEff,"M");
+ P[12]=m_tag_COMB_w->KolmogorovTest(ex_tag_COMB_w,"M");
+ P[13]=m_tag_IP1D_w->KolmogorovTest(ex_tag_IP1D_w,"M");
+ P[14]=m_tag_IP2D_w->KolmogorovTest(ex_tag_IP2D_w,"M");
+ P[15]=m_tag_IP3D_w->KolmogorovTest(ex_tag_IP3D_w,"M");
+
+
+ TCanvas* c1 = new TCanvas("c1","cuts",0,0,1200,1000);
+ c1->Divide(4,4);
+
+ c1->cd(1);
+ m_jet_electrons_n->Draw();
+ ex_jet_electrons_n->Draw("same");
+ if(P[0]<0.15)
+ c1_1->SetFillColor(kGreen);
+ else if (P[0]<0.3)
+ c1_1->SetFillColor(kYellow);
+ else
+ c1_1->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_jet_electrons_n -> SetAxisRange(0.01, Max[0]*1.2, "Y");
+ leg1 = new TLegend(0.9,0.6,0.55,0.8);
+ leg1->AddEntry(m_jet_electrons_n,"Reference","l");
+ leg1->AddEntry(ex_jet_electrons_n,"Data","l");
+ leg1->Draw();
+
+ c1->cd(2);
+ m_jet_muons_n->Draw();
+ ex_jet_muons_n->Draw("same");
+ if(P[1]<0.15)
+ c1_2->SetFillColor(kGreen);
+ else if (P[1]<0.3)
+ c1_2->SetFillColor(kYellow);
+ else
+ c1_2->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ gPad->SetLogy();
+ m_jet_muons_n -> SetAxisRange(1e-5, Max[1]*2, "Y");
+
+ c1->cd(3);
+ m_jet_tracks_hits_BLayer->Draw();
+ ex_jet_tracks_hits_BLayer->Draw("same");
+ if(P[2]<0.15)
+ c1_3->SetFillColor(kGreen);
+ else if (P[2]<0.3)
+ c1_3->SetFillColor(kYellow);
+ else
+ c1_3->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_jet_tracks_hits_BLayer -> SetAxisRange(0, Max[2]*1.2, "Y");
+
+ c1->cd(4);
+ m_jet_tracks_hits_Pixel->Draw();
+ ex_jet_tracks_hits_Pixel->Draw("same");
+ if(P[3]<0.15)
+ c1_4->SetFillColor(kGreen);
+ else if (P[3]<0.3)
+ c1_4->SetFillColor(kYellow);
+ else
+ c1_4->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_jet_tracks_hits_Pixel -> SetAxisRange(0, Max[3]*1.2, "Y");
+
+ c1->cd(5);
+ m_jet_tracks_hits_SCT->Draw();
+ ex_jet_tracks_hits_SCT->Draw("same");
+ if(P[4]<0.15)
+ c1_5->SetFillColor(kGreen);
+ else if (P[4]<0.3)
+ c1_5->SetFillColor(kYellow);
+ else
+ c1_5->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_jet_tracks_hits_SCT -> SetAxisRange(0, Max[4]*1.2, "Y");
+
+ c1->cd(6);
+ m_jet_tracks_n->Draw();
+ ex_jet_tracks_n->Draw("same");
+ if(P[5]<0.15)
+ c1_6->SetFillColor(kGreen);
+ else if (P[5]<0.3)
+ c1_6->SetFillColor(kYellow);
+ else
+ c1_6->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_jet_tracks_n -> SetAxisRange(0, Max[5]*1.2, "Y");
+
+ c1->cd(7);
+ m_jetProb->Draw();
+ ex_jetProb->Draw("same");
+ if(P[6]<0.15)
+ c1_7->SetFillColor(kGreen);
+ else if (P[6]<0.3)
+ c1_7->SetFillColor(kYellow);
+ else
+ c1_7->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ gPad->SetLogy();
+ m_jetProb -> SetAxisRange(1e-3, Max[6]*2, "Y");
+
+ c1->cd(8);
+ m_sv0->Draw();
+ ex_sv0->Draw("same");
+ if(P[7]<0.01)
+ c1_8->SetFillColor(kGreen);
+ else if (P[7]<0.03)
+ c1_8->SetFillColor(kYellow);
+ else
+ c1_8->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ gPad->SetLogy();
+ m_sv0 -> SetAxisRange(1e-5, Max[7]*2, "Y");
+
+ c1->cd(9);
+ m_trkCnt->Draw();
+ ex_trkCnt->Draw("same");
+ if(P[8]<0.15)
+ c1_9->SetFillColor(kGreen);
+ else if (P[8]<0.3)
+ c1_9->SetFillColor(kYellow);
+ else
+ c1_9->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ gPad->SetLogy();
+ m_trkCnt -> SetAxisRange(1e-3, Max[8]*2, "Y");
+
+ c1->cd(10);
+ m_SOFTE->Draw();
+ ex_SOFTE->Draw("same");
+ if(P[9]<0.15)
+ c1_10->SetFillColor(kGreen);
+ else if (P[9]<0.3)
+ c1_10->SetFillColor(kYellow);
+ else
+ c1_10->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_SOFTE -> SetAxisRange(0, Max[9]*1.2, "Y");
+
+ c1->cd(11);
+ m_SOFTM->Draw();
+ ex_SOFTM->Draw("same");
+ if(P[10]<0.15)
+ c1_11->SetFillColor(kGreen);
+ else if (P[10]<0.3)
+ c1_11->SetFillColor(kYellow);
+ else
+ c1_11->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_SOFTM -> SetAxisRange(0, Max[10]*1.2, "Y");
+
+ c1->cd(12);
+ // m_trackSelEff->Draw("colz");
+ ex_trackSelEff->Draw("colz");
+ if(P[11]<0.15)
+ c1_12->SetFillColor(kGreen);
+ else if (P[11]<0.3)
+ c1_12->SetFillColor(kYellow);
+ else
+ c1_12->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_trackSelEff -> SetAxisRange(0, Max[11]*1.2, "Y");
+ m_trackSelEff -> SetAxisRange(0, Max[11]*1.2, "X");
+
+
+ c1->cd(13);
+ m_tag_COMB_w->Draw();
+ ex_tag_COMB_w->Draw("same");
+ if(P[12]<0.15)
+ c1_13->SetFillColor(kGreen);
+ else if (P[11]<0.3)
+ c1_13->SetFillColor(kYellow);
+ else
+ c1_13->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_tag_COMB_w -> SetAxisRange(0, Max[12]*1.2, "Y");
+
+
+ c1->cd(14);
+ m_tag_IP1D_w->Draw();
+ ex_tag_IP1D_w->Draw("same");
+ if(P[13]<0.15)
+ c1_14->SetFillColor(kGreen);
+ else if (P[13]<0.3)
+ c1_14->SetFillColor(kYellow);
+ else
+ c1_14->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_tag_IP1D_w -> SetAxisRange(0, Max[13]*1.2, "Y");
+
+
+ c1->cd(15);
+ m_tag_IP2D_w->Draw();
+ ex_tag_IP2D_w->Draw("same");
+ if(P[14]<0.15)
+ c1_15->SetFillColor(kGreen);
+ else if (P[14]<0.3)
+ c1_15->SetFillColor(kYellow);
+ else
+ c1_15->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_tag_IP2D_w -> SetAxisRange(0, Max[14]*1.2, "Y");
+
+
+ c1->cd(16);
+ m_tag_IP3D_w->Draw();
+ ex_tag_IP3D_w->Draw("same");
+ if(P[15]<0.15)
+ c1_16->SetFillColor(kGreen);
+ else if (P[15]<0.3)
+ c1_16->SetFillColor(kYellow);
+ else
+ c1_16->SetFillColor(kRed);
+ gPad->SetFrameFillColor(10);
+ m_tag_IP3D_w -> SetAxisRange(0, Max[15]*1.2, "Y");
+
+
+ P[0]=m_jet_electrons_n->KolmogorovTest(ex_jet_electrons_n,"M");
+ P[1]=m_jet_muons_n->KolmogorovTest(ex_jet_muons_n,"M");
+ P[2]=m_jet_tracks_hits_BLayer->KolmogorovTest(ex_jet_tracks_hits_BLayer,"M");
+ P[3]=m_jet_tracks_hits_Pixel->KolmogorovTest(ex_jet_tracks_hits_Pixel,"M");
+ P[4]=m_jet_tracks_hits_SCT->KolmogorovTest(ex_jet_tracks_hits_SCT,"M");
+ P[5]=m_jet_tracks_n->KolmogorovTest(ex_jet_tracks_n,"M");
+ P[6]=m_jetProb->KolmogorovTest(ex_jetProb,"M");
+ P[7]=m_sv0->KolmogorovTest(ex_sv0,"M");
+ P[8]=m_trkCnt->KolmogorovTest(ex_trkCnt,"M");
+ P[9]=m_SOFTE->KolmogorovTest(ex_SOFTE,"M");
+ P[10]=m_SOFTM->KolmogorovTest(ex_SOFTM,"M");
+ P[11]=m_trackSelEff->KolmogorovTest(ex_trackSelEff,"M");
+ P[12]=m_tag_COMB_w->KolmogorovTest(ex_tag_COMB_w,"M");
+ P[13]=m_tag_IP1D_w->KolmogorovTest(ex_tag_IP1D_w,"M");
+ P[14]=m_tag_IP2D_w->KolmogorovTest(ex_tag_IP2D_w,"M");
+ P[15]=m_tag_IP3D_w->KolmogorovTest(ex_tag_IP3D_w,"M");
+ cout<<"MaxDifference value of KolmogorovTest for next variables:"<<endl;
+ cout<<"jet_electrons_n: "<<P[0]<<endl;
+ cout<<"jet_muons_n: "<<P[1]<<endl;
+ cout<<"jet_tracks_hits_BLayer: "<<P[2]<<endl;
+ cout<<"jet_tracks_hits_Pixel: "<<P[3]<<endl;
+ cout<<"jet_tracks_hits_SCT: "<<P[4]<<endl;
+ cout<<"jet_tracks_n: "<<P[5]<<endl;
+ cout<<"jetProb: "<<P[6]<<endl;
+ cout<<"sv0: "<<P[7]<<endl;
+ cout<<"trkCnt: "<<P[8]<<endl;
+ cout<<"SOFTE: "<<P[9]<<endl;
+ cout<<"SOFTM: "<<P[10]<<endl;
+ cout<<"track_selector_eff: "<<P[11]<<endl;
+ cout<<"tag_COMB_w: "<<P[12]<<endl;
+ cout<<"tag_IP1D_w: "<<P[13]<<endl;
+ cout<<"tag_IP2D_w: "<<P[14]<<endl;
+ cout<<"tag_IP3D_w: "<<P[15]<<endl;
+
+ char name1[32];
+ char name2[32];
+
+ sprintf(name1,"dq_%s.pdf", run.c_str());
+ sprintf(name2,"dq_%s.png", run.c_str());
+
+ c1->Print(name1);
+ c1->Print(name2);
+ return ;
+}
+
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagging_test.py b/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagging_test.py
new file mode 100644
index 00000000000..4ced4475564
--- /dev/null
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagging_test.py
@@ -0,0 +1,174 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+#simple script to compare the actual data file with a reference and give a result depending on a
+#K test
+# use with > ./JetTagging_test.py [data file] [reference file] > ktest_[run].txt
+# so you'll get an pdf file with an graphical representation and the actual test result in
+# the text file.
+
+
+import ROOT, sys, math, time, re
+#from ROOT import gROOT, TCanvas, TH1, TH2, TH1F
+
+h2list = []
+
+
+
+if __name__ == "__main__":
+
+ ROOT.gStyle.SetPalette(1)
+
+ #Reference file (maybe outdated
+ MonFile = "root://castoratlas//castor/cern.ch/grid/atlas/caf/atlcal/perm/dataqual/han_references/Collisions/data11_7TeV.00183347.express_express.merge.HIST.f384_m875._0001.1.root"
+
+ print sys.argv
+
+ tf = ROOT.TFile.Open(sys.argv[1])
+
+ if len(sys.argv) > 2:
+ tfref = ROOT.TFile.Open(sys.argv[2])
+ else:
+ tfref = ROOT.TFile.Open(MonFile)
+
+ #get run number from root directory
+ rDir = tf.GetListOfKeys()[0].GetName()
+ runTemp = re.search("\d{5,8}", rDir )
+ if len(runTemp.group(0))==6:
+ run = runTemp.group(0)
+ elif len(runTemp.group(0))==8:
+ run = runTemp.group(0)[2:8]
+ else:
+ print ("No run number in the filename %s in format XXXXXX or 00XXXXXX given" % tf.GetName() )
+
+ print "run number from data file:\t %s " % run
+
+ #get run number of reference from root directory
+ rDir = tfref.GetListOfKeys()[0].GetName()
+ runTempRef = re.search("\d{5,8}", rDir )
+ if len(runTempRef.group(0))==6:
+ runref = runTempRef.group(0)
+ elif len(runTempRef.group(0))==8:
+ runref = runTempRef.group(0)[2:8]
+ else:
+ print ("No run number in reference filename %s in format XXXXXX or 00XXXXXX given" % tfref.GetName() )
+
+ print "run number from reference file:\t %s " % runref
+
+
+
+
+
+
+ #Define "to look at" histograms
+ histDict = { "jet_electrons_n" : { "LogY" : True, "PosInCanvas" : 1},
+ "jet_muons_n" : { "LogY" : False, "PosInCanvas" : 2},
+ "jet_tracks_hits_BLayer" : { "LogY" : False, "PosInCanvas" : 3},
+ "jet_tracks_hits_Pixel" : { "LogY" : False, "PosInCanvas" : 4},
+ "jet_tracks_hits_SCT" : { "LogY" : False, "PosInCanvas" : 5},
+ "jet_tracks_n" : { "LogY" : True, "PosInCanvas" : 0},
+ "tag_JetProb_w" : { "LogY" : True, "PosInCanvas" : 0},
+ "tag_SV0_w" : { "LogY" : True, "PosInCanvas" : 6},
+ "tag_COMB_w" : { "LogY" : False, "PosInCanvas" : 7},
+ "tag_IP1D_w" : { "LogY" : False, "PosInCanvas" : 0},
+ "tag_IP2D_w" : { "LogY" : False, "PosInCanvas" : 0},
+ "tag_IP3D_w" : { "LogY" : False, "PosInCanvas" : 8},
+ "tag_TrkCnt_w" : { "LogY" : False, "PosInCanvas" : 0},
+ "tag_SOFTE_w" : { "LogY" : False, "PosInCanvas" : 0},
+ "tag_SOFTM_w" : { "LogY" : False, "PosInCanvas" : 0},
+ "track_selector_eff" : { "LogY" : False, "PosInCanvas" : 9}
+ }
+
+ #list for the test results
+ KolmogorovResult = [ 0.0, 0.0, 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0, 0.0, 0.0,
+ 0.0, 0.0, 0.0]
+
+ #histogram with all tracks (to normalise)
+ ref2d = tf.Get("run_%s/JetTagging/track_selector_all" % run )
+
+ #open canvas
+ c2 = ROOT.TCanvas("c2", "Histograms for shifters", 0, 0, 1200, 1000)
+ c2.Divide(3, 3)
+
+ #iterate through the histograms
+ for key,value in histDict.iteritems():
+ if value["PosInCanvas"] == 0:
+ continue
+ print "opening histogram %s" % key
+ c2.cd(value["PosInCanvas"])
+ if key == "track_selector_eff":
+ #special theatment of 2D histos
+
+ h4 = tf.Get("run_%s/JetTagging/%s" % (run, key))
+ if h4 is None :
+ print "hist ", key, " not found"
+ h4.Divide(ref2d)
+ c2.cd(value["PosInCanvas"])
+ h4.Draw("colz")
+
+ else:
+ #all others
+
+
+ #get and check entries
+ h2 = tf.Get("run_%s/JetTagging/%s" % (run, key))
+ #h3 = ROOT.TH1F(tfref.Get("run_%s/JetTagging/%s" % (runref, key)))
+ if h2 is None :
+ print "hist ", key, " not found"
+
+ h3 = tfref.Get("run_%s/JetTagging/%s" % (runref, key))
+ if h3 is None :
+ print "hist ", key, " not found"
+
+ #c2.cd(value["PosInCanvas"])
+
+
+
+ # check if histos have entries and normalise them
+ if h2.Integral() > 0 and h3.Integral() > 0 :
+ if value["LogY"]==True:
+ ROOT.gPad.SetLogy(1)
+ else:
+ ROOT.gPad.SetLogy(0)
+ h2.Scale(1. / h2.Integral())
+ h3.Scale(1. / h3.Integral())
+
+ # compare them
+ KolmogorovResult[value["PosInCanvas"]] = h3.KolmogorovTest(h2,"M")
+ print "KolmogorovResult for %s: %g" % (h2.GetName(), KolmogorovResult[value["PosInCanvas"]])
+
+ #line styling
+ h3.SetLineColor(2)
+ h2.SetLineColor(4)
+ ROOT.gPad.SetFrameFillColor(10)
+
+ # depending on test result the frames got red (all ok), yellow, red (bad result) colour
+ if(KolmogorovResult[value["PosInCanvas"]] < 0.15):
+ c2.cd(value["PosInCanvas"]).SetFillColor(3)
+ elif (KolmogorovResult[value["PosInCanvas"]] < 0.3):
+ c2.cd(value["PosInCanvas"]).SetFillColor(5)
+ else:
+ c2.cd(value["PosInCanvas"]).SetFillColor(2)
+
+ #draw the histos
+ h2.Draw("")
+ h3.Draw("same")
+ else:
+ print "Integral of % s was 0" % key
+ h3.SetLineColor(2)
+ h2.SetLineColor(4)
+ h2.Draw("")
+ h3.Draw("same")
+
+ #print "Closed histogram %s" % key
+ c2.SaveAs("JetTaggingDQ_%s_run-%s.pdf" % ( time.strftime("%Y%m%d", time.localtime()), run))
+
+
+
+
+
+
+
+
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/switchMon.py b/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/switchMon.py
new file mode 100644
index 00000000000..282fc99abf1
--- /dev/null
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/switchMon.py
@@ -0,0 +1,47 @@
+### switchMon.py
+###
+### written by Marcello Barisonzi
+### marcello.barisonzi(at)cern.ch
+###
+### Usage: switch off all other monitoring
+### when testing with a transform
+###
+### Example:
+###
+### Reco_trf.py inputESDFile=/tmp/mbarison/data10_7TeV.00166142.physics_JetTauEtmiss.merge.ESD.r1774_p327_tid203218_00/ESD.203218._000059.pool.root.1,/tmp/mbarison/data10_7TeV.00166142.physics_JetTauEtmiss.merge.ESD.r1774_p327_tid203218_00/ESD.203218._000542.pool.root.1 autoConfiguration=everything outputHISTFile=myMergedMonitoring.root preExec="execfile(os.path.expanduser('~/switchMon.py'))"
+###
+###
+###
+###
+
+from AthenaMonitoring.DQMonFlags import DQMonFlags
+
+DQMonFlags.doStreamAwareMon = False
+
+DQMonFlags.doCTPMon = False
+DQMonFlags.doCaloMon = False
+DQMonFlags.doEgammaMon = False
+DQMonFlags.doGlobalMon = True
+DQMonFlags.doHLTMon = False
+DQMonFlags.doInDetAlignMon = False
+DQMonFlags.doInDetGlobalMon = False
+DQMonFlags.doInDetPerfMon = False
+DQMonFlags.doJetMon = False
+DQMonFlags.doJetTagMon = True
+DQMonFlags.doLArMon = False
+DQMonFlags.doLVL1CaloMon = False
+DQMonFlags.doLucidMon = False
+DQMonFlags.doMissingEtMon = False
+DQMonFlags.doMuonAlignMon = False
+DQMonFlags.doMuonCombinedMon = False
+DQMonFlags.doMuonPhysicsMon = False
+DQMonFlags.doMuonRawMon = False
+DQMonFlags.doMuonSegmentMon = False
+DQMonFlags.doMuonTrackMon = False
+DQMonFlags.doMuonTrkPhysMon = False
+DQMonFlags.doPixelMon = False
+DQMonFlags.doSCTMon = False
+DQMonFlags.doTRTElectronMon = False
+DQMonFlags.doTRTMon = False
+DQMonFlags.doTauMon = False
+DQMonFlags.doTileMon = False
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/src/JetTagMonitoring.cxx b/PhysicsAnalysis/JetTagging/JetTagMonitoring/src/JetTagMonitoring.cxx
new file mode 100755
index 00000000000..5b115b9db77
--- /dev/null
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/src/JetTagMonitoring.cxx
@@ -0,0 +1,1201 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//#include "ITrackToVertex/ITrackToVertex.h"
+#include "xAODJet/JetContainer.h"
+#include "xAODJet/JetAttributes.h"
+#include "xAODBTagging/BTagging.h"
+#include "xAODEventInfo/EventInfo.h"
+
+#include "JetTagMonitoring/JetTagMonitoring.h"
+#include "JetTagTools/TrackSelector.h"
+
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTracking/TrackParticleContainer.h"
+
+#include "TrigDecisionTool/TrigDecisionTool.h"
+#include "TrkParticleBase/LinkToTrackParticleBase.h"
+#include "TrkVertexFitterInterfaces/ITrackToVertexIPEstimator.h"
+#include "VxSecVertex/VxSecVKalVertexInfo.h"
+#include "VxSecVertex/VxSecVertexInfo.h"
+
+#include "LArRecEvent/LArEventBitInfo.h"
+
+#include "LWHists/LWHist.h"
+#include "LWHists/TH1F_LW.h"
+#include "LWHists/TH2F_LW.h"
+
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TMath.h"
+
+#include <vector>
+#include <string>
+#include <sstream>
+
+//** --------------------------------------------------------------------------------------------------------------- **//
+
+// Private methods
+
+namespace {
+
+template< class T >
+bool retrieveCollection(const ServiceHandle<StoreGateSvc>& sg, const DataHandle<T>& coll, std::string key ) {
+
+ StatusCode sc;
+ sc = sg->retrieve( coll, key );
+
+ if (!sc.isSuccess())
+ return false;
+
+ return true;
+}
+
+} // unnamed namespace
+
+
+//** --------------------------------------------------------------------------------------------------------------- **//
+
+
+JetTagMonitoring::JetTagMonitoring(const std::string & type, const std::string & name, const IInterface* parent) :
+ ManagedMonitorToolBase(type, name, parent),
+ m_storeGate( "StoreGateSvc", name ),
+ m_trackSelectorTool("Analysis::TrackSelector"),
+ m_trackToVertexTool("Reco::TrackToVertex"),
+ m_histogramsCreated(false),
+ m_switch_off(false),
+ m_pixelCondSummarySvc("PixelConditionsSummarySvc",name)
+{
+
+ declareProperty("JetContainer", m_jetName = "AntiKt4TopoJets");
+ declareProperty("TrackParticleContainer", m_trackParticleName = "TrackParticleCandidate");
+ declareProperty("PrimaryVertexContainer", m_primaryVertexName = "VxPrimaryCandidate");
+
+ declareProperty("DQcuts", m_do_cuts = true);
+
+ declareProperty("PriVtxTrkMinCut", m_pri_vtx_trk_min_cut = 4 );
+ declareProperty("D0_min_cuts", m_trk_d0_min_cut = 0);
+ declareProperty("D0_max_cuts", m_trk_d0_max_cut = 1);
+ declareProperty("JetPt_cuts", m_jet_pt_cut = 15e3);
+ declareProperty("JetEta_cuts", m_jet_eta_cut = 2.5);
+ declareProperty("nTrk_cuts", m_trk_n = 1);
+ declareProperty("SV0_weight_cut", m_sv0_weight_cut=0.);
+ declareProperty("SV1_weight_cut", m_sv1_weight_cut=0.);
+ declareProperty("SV2_weight_cut", m_sv2_weight_cut=0.);
+ declareProperty("IP1D_weight_cut", m_ip1d_weight_cut=0.);
+ declareProperty("IP2D_weight_cut", m_ip2d_weight_cut=0.);
+ declareProperty("IP3D_weight_cut", m_ip3d_weight_cut=0.);
+ declareProperty("SV1IP3D_weight_cut", m_sv1ip3d_weight_cut=0.);
+ declareProperty("JetFitterCOMBNN_weight_cut", m_jfcnn_weight_cut=0.);
+ declareProperty("MV1_weight_cut", m_mv1_weight_cut=0.601713);
+ declareProperty("UseTrackSelector", m_use_trackselector = true);
+ declareProperty("UseTrigDecisionTool", m_use_trigdectool = true);
+ declareProperty("doLumiBlock", m_doLumiBlock=false);
+ declareProperty("doStatus", m_doStatus = false);
+
+ m_isNewLumiBlock = false;
+}
+
+//** --------------------------------------------------------------------------------------------------------------- **//
+
+
+JetTagMonitoring::~JetTagMonitoring() {}
+
+
+//** --------------------------------------------------------------------------------------------------------------- **//
+
+
+StatusCode JetTagMonitoring::registerHist(MonGroup& theGroup, TH1* h1) {
+
+ msg(MSG::VERBOSE) << "in JetTagMonitoring::registerHist " << h1->GetName() << endreq;
+
+ StatusCode sc = theGroup.regHist(h1);
+ if (!sc.isSuccess())
+ msg(MSG::WARNING) << "Could not register histogram " << endreq;
+
+ return sc;
+}
+
+//** --------------------------------------------------------------------------------------------------------------- **//
+
+
+StatusCode JetTagMonitoring::registerHist(MonGroup& theGroup, LWHist* h1) {
+
+ msg(MSG::VERBOSE) << "in JetTagMonitoring::registerHist " << h1->GetName() << endreq;
+
+ StatusCode sc = theGroup.regHist(h1);
+ if (!sc.isSuccess())
+ msg(MSG::WARNING) << "Could not register histogram " << endreq;
+
+ return sc;
+}
+
+
+//** --------------------------------------------------------------------------------------------------------------- **//
+
+
+
+
+
+//** --------------------------------------------------------------------------------------------------------------- **//
+
+
+
+
+StatusCode JetTagMonitoring::initialize() {
+
+ msg(MSG::INFO) << "in JetTagMonitoring::initialize" << endreq;
+
+ StatusCode sc = ManagedMonitorToolBase::initialize();
+ if (!sc.isSuccess()) {
+ msg(MSG::WARNING) << "Unable to initialize ManagedMonitorToolBase" << endreq;
+ return sc;
+ }
+
+ sc = m_storeGate.retrieve();
+ if (!sc.isSuccess()) {
+ msg(MSG::WARNING) << "Unable to retrieve StoreGateSvc handle" << endreq;
+ m_switch_off = true;
+ }
+
+ if ( m_use_trackselector ) {
+ if ( m_trackSelectorTool.retrieve().isFailure() ) {
+ msg(MSG::WARNING) << "Failed to retrieve tool " << m_trackSelectorTool << endreq;
+ m_switch_off = true;
+ }
+ } else {
+ msg(MSG::INFO) << "Analysis::TrackSelector not used" << endreq;
+ }
+
+ if ( m_switch_off )
+ msg(MSG::WARNING) << "Switching off JetTagMonitoring::fillHistograms()" << endreq;
+
+ m_lumiBlockNum = 0;
+
+ return StatusCode::SUCCESS;
+}
+
+
+//** --------------------------------------------------------------------------------------------------------------- **//
+
+
+StatusCode JetTagMonitoring::bookHistograms() {
+
+ msg(MSG::DEBUG) << "bookHistograms()" << endreq;
+
+ m_isNewLumiBlock = newLumiBlock;
+ if ( !newRun ) {
+ // Only book run-length histogram
+ return StatusCode::SUCCESS;
+ }
+
+
+ if ( (m_environment != AthenaMonManager::tier0) &&
+ (m_environment != AthenaMonManager::tier0ESD) &&
+ (m_environment != AthenaMonManager::online) ) {
+ // Only produce histograms from ESD, or from RAW if ESD-only monitoring is not enabled
+ msg(MSG::INFO) << "Monitoring environment is \'" << m_environment << "\', not booking histograms" << endreq;
+ return StatusCode::SUCCESS;
+ }
+
+ if ( m_dataType == AthenaMonManager::cosmics ) {
+ msg(MSG::INFO) << "Cosmic-ray data, not booking histograms" << endreq;
+ return StatusCode::SUCCESS;
+ }
+
+ msg(MSG::INFO) << "Monitoring environment is \'" << m_environment << "\', data type is \'" << m_dataType
+ << "\', booking histograms now." << endreq;
+
+
+ m_monGr_shift = new MonGroup( this, "JetTagging", run );
+ m_monGr_LowStat = new MonGroup( this, "JetTagging", lowStat );
+
+ registerHist(*m_monGr_shift, m_tag_ip2d_w = TH1F_LW::create("tag_IP2D_w","IP2D weight",125,-25.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip2d_n = TH1F_LW::create("tag_IP2D_n","IP2D # of tracks",20,0.,20.));
+ registerHist(*m_monGr_shift, m_tag_ip2d_b = TH1F_LW::create("tag_IP2D_b","IP2D Pb",10,0.,1.));
+ registerHist(*m_monGr_shift, m_tag_ip2d_u = TH1F_LW::create("tag_IP2D_u","IP2D Pu",10,0.,1.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_w = TH1F_LW::create("tag_IP3D_w","IP3D weight",195,-25.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_n = TH1F_LW::create("tag_IP3D_n","IP3D # of tracks",20,0.,20.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_b = TH1F_LW::create("tag_IP3D_b","IP3D Pb",10,0.,1.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_u = TH1F_LW::create("tag_IP3D_u","IP3D Pu",10,0.,1.));
+ registerHist(*m_monGr_shift, m_tag_sv0_w = TH1F_LW::create("tag_SV0_w","SV0 weight",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_sv1_w = TH1F_LW::create("tag_SV1_w","SV1 weight",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_sv2_w = TH1F_LW::create("tag_SV2_w","SV2 weight",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_lf2d_w = TH1F_LW::create("tag_LF2D_w","LifeTime2D weight",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_svbu_w = TH1F_LW::create("tag_SVBU_w","SecVtxTagBU weight",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_lhsig_w = TH1F_LW::create("tag_LHSIG_w","lhSig weight",160,-120.,120.));
+ registerHist(*m_monGr_shift, m_tag_softm_w = TH1F_LW::create("tag_SOFTM_w","SoftMuonTag weight",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_comb_w = TH1F_LW::create("tag_COMB_w","Combined weight IP3D+SV1",120,-2.,10.));
+ registerHist(*m_monGr_shift, m_tag_jfcnn_w = TH1F_LW::create("tag_JFCNN_w","Combined weight JetFitterCOMBNN",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_mv1_w = TH1F_LW::create("tag_MV1_w","Combined weight MV1",210,-1.,1.1));
+
+ /*
+ registerHist(*m_monGr_shift, m_tag_sv0_w_sj = TH1F_LW::create("tag_SV0_w_sj","SV0 weight Suspect Jets",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_comb_w_sj = TH1F_LW::create("tag_COMB_w_sj","Combined weight IP3D+SV1 Suspect Jets",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_jfcnn_w_sj = TH1F_LW::create("tag_JFCNN_w_sj","Combined weight JetFitterCOMBNN Suspect Jets",120,-20.,40.));
+
+ registerHist(*m_monGr_shift, m_tag_sv0_w_DMZ1 = TH1F_LW::create("tag_SV0_w_DMZ1","SV0 weight DMZ1",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_comb_w_DMZ1 = TH1F_LW::create("tag_COMB_w_DMZ1","Combined weight IP3D+SV1 DMZ1",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_jfcnn_w_DMZ1 = TH1F_LW::create("tag_JFCNN_w_DMZ1","Combined weight JetFitterCOMBNN DMZ1",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ1 = TH1F_LW::create("tag_IP3D_w_DMZ1","Combined weight IP3D DMZ1",120,-21.,40.));
+
+ registerHist(*m_monGr_shift, m_tag_sv0_w_DMZ2 = TH1F_LW::create("tag_SV0_w_DMZ2","SV0 weight DMZ2",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_comb_w_DMZ2 = TH1F_LW::create("tag_COMB_w_DMZ2","Combined weight IP3D+SV1 DMZ2",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_jfcnn_w_DMZ2 = TH1F_LW::create("tag_JFCNN_w_DMZ2","Combined weight JetFitterCOMBNN DMZ2",120,-20.,40.));
+
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ2 = TH1F_LW::create("tag_IP3D_w_DMZ2","Combined weight IP3D DMZ2",120,-21.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ2_x1 = TH1F_LW::create("tag_IP3D_w_DMZ2_x1","Combined weight IP3D DMZ2 x1",120,-21.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ2_x2 = TH1F_LW::create("tag_IP3D_w_DMZ2_x2","Combined weight IP3D DMZ2 x2",120,-21.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ2_x4 = TH1F_LW::create("tag_IP3D_w_DMZ2_x4","Combined weight IP3D DMZ2 x4",120,-21.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ2_x8 = TH1F_LW::create("tag_IP3D_w_DMZ2_x8","Combined weight IP3D DMZ2 x8",120,-21.,40.));
+
+ registerHist(*m_monGr_shift, m_tag_sv0_w_DMZ3 = TH1F_LW::create("tag_SV0_w_DMZ3","SV0 weight DMZ3",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_comb_w_DMZ3 = TH1F_LW::create("tag_COMB_w_DMZ3","Combined weight IP3D+SV1 DMZ3",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_jfcnn_w_DMZ3 = TH1F_LW::create("tag_JFCNN_w_DMZ3","Combined weight JetFitterCOMBNN DMZ3",120,-20.,40.));
+
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ3 = TH1F_LW::create("tag_IP3D_w_DMZ3","Combined weight IP3D DMZ3",120,-21.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ3_x1 = TH1F_LW::create("tag_IP3D_w_DMZ3_x1","Combined weight IP3D DMZ3 x1",120,-21.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ3_x2 = TH1F_LW::create("tag_IP3D_w_DMZ3_x2","Combined weight IP3D DMZ3 x2",120,-21.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ3_x4 = TH1F_LW::create("tag_IP3D_w_DMZ3_x4","Combined weight IP3D DMZ3 x4",120,-21.,40.));
+ registerHist(*m_monGr_shift, m_tag_ip3d_w_DMZ3_x8 = TH1F_LW::create("tag_IP3D_w_DMZ3_x8","Combined weight IP3D DMZ3 x8",120,-21.,40.));
+ */
+
+ registerHist(*m_monGr_shift, m_tag_trkcnt_w =
+ TH1F_LW::create("tag_TrkCnt_w","TrackCounting2D",120,-20.,40.));
+ registerHist(*m_monGr_shift, m_tag_jetprob_w =
+ TH1F_LW::create("tag_JetProb_w","JetProb",120,0.,1.01));
+
+ registerHist(*m_monGr_shift, m_jet_n =
+ TH1F_LW::create("jet_n","number of jets",20,0.,20.));
+
+ registerHist(*m_monGr_shift, m_global_nPrimVtx =
+ TH1F_LW::create("global_nPrimVtx","# primary vertex",30,0.,30.));
+ registerHist(*m_monGr_shift, m_global_xPrimVtx =
+ TH1F_LW::create("global_xPrimVtx","x primary vertex",100,-0.5,0.5));
+ registerHist(*m_monGr_shift, m_global_yPrimVtx =
+ TH1F_LW::create("global_yPrimVtx","y primary vertex",100,-1.2,1.2));
+ registerHist(*m_monGr_shift, m_global_zPrimVtx =
+ TH1F_LW::create("global_zPrimVtx","z primary vertex",100,-250.,250.));
+
+ registerHist(*m_monGr_shift, m_global_BLayerHits =
+ TH1F_LW::create("global_BLayerHits","# of BLayer hits on TrackParticle",5,0.,5.));
+ registerHist(*m_monGr_shift, m_global_PixelHits =
+ TH1F_LW::create("global_PixelHits","# of Pixel hits on TrackParticle",10,0.,10.));
+ registerHist(*m_monGr_shift, m_global_SCTHits =
+ TH1F_LW::create("global_SCTHits","# of SCT hits on TrackParticle",15,0.,15.));
+ registerHist(*m_monGr_shift, m_global_SiHits =
+ TH1F_LW::create("global_SiHits","# of pixel+SCT hits on TrackParticle",25,0.,25.));
+ registerHist(*m_monGr_shift, m_global_TRTHits =
+ TH1F_LW::create("global_TRTHits","# of TRT hits on TrackParticle",100,0.,100.));
+
+ registerHist(*m_monGr_shift, m_trackParticle_n = TH1F_LW::create("NTrackParticle","number of TrackParticles",100,0.,1000.));
+
+ registerHist(*m_monGr_shift, m_jet_nTag = TH1F_LW::create("jet_nTag","# tags",20,0.,20.));
+ registerHist(*m_monGr_shift, m_jet_eta = TH1F_LW::create("jet_eta","Jet eta",100,-5.,5.));
+ registerHist(*m_monGr_shift, m_jet_phi = TH1F_LW::create("jet_phi","Jet phi",100,-3.15,3.15));
+ registerHist(*m_monGr_shift, m_jet_et = TH1F_LW::create("jet_et","Jet et",100,0.,500000.));
+
+ registerHist(*m_monGr_shift, m_jet_tracks_n =
+ TH1F_LW::create("jet_tracks_n","# of tracks in a jet",50,0.,50.));
+ registerHist(*m_monGr_shift, m_jet_tracks_pt =
+ TH1F_LW::create("jet_tracks_pt","pT of tracks in a jet",100,0.,100.));
+ registerHist(*m_monGr_shift, m_jet_tracks_eta =
+ TH1F_LW::create("jet_tracks_eta","#eta of tracks in a jet",100,-2.5,2.5));
+ registerHist(*m_monGr_shift, m_jet_tracks_phi =
+ TH1F_LW::create("jet_tracks_phi","#varphi of tracks in a jet",100,-TMath::Pi(),TMath::Pi()));
+ registerHist(*m_monGr_shift, m_jet_tracks_BLayerHits =
+ TH1F_LW::create("jet_tracks_hits_BLayer","# of BLayer hits per track in a jet",5,0.,5.));
+ registerHist(*m_monGr_shift, m_jet_tracks_PixelHits =
+ TH1F_LW::create("jet_tracks_hits_Pixel","# of Pixel hits per track in a jet",10,0.,10.));
+ registerHist(*m_monGr_shift, m_jet_tracks_SCTHits =
+ TH1F_LW::create("jet_tracks_hits_SCT","# of SCT hits per track in a jet",15,0.,15.));
+ registerHist(*m_monGr_shift, m_jet_muons_n =
+ TH1F_LW::create("jet_muons_n","# of muons in a jet",10,0.,10.));
+ registerHist(*m_monGr_shift, m_jet_muons_pt =
+ TH1F_LW::create("jet_muons_pt","pT of muons in a jet",100,0.,100.));
+ registerHist(*m_monGr_shift, m_jet_electrons_n =
+ TH1F_LW::create("jet_electrons_n","# of electrons in a jet",10,0.,10.));
+ registerHist(*m_monGr_shift, m_jet_electrons_pt =
+ TH1F_LW::create("jet_electrons_pt","pT of electrons in a jet",100,0.,100.));
+
+ registerHist(*m_monGr_shift, m_trigPassed =
+ TH1F_LW::create("trigPassed","Number of events passed trigger chains",25,0.,25.));
+
+
+ m_trigPassed->GetXaxis()->SetBinLabel(1,"L1_J10") ;
+ m_trigPassed->GetXaxis()->SetBinLabel(2,"L1_J15") ;
+ m_trigPassed->GetXaxis()->SetBinLabel(3,"L1_J20") ;
+ m_trigPassed->GetXaxis()->SetBinLabel(4,"L1_J30") ;
+ m_trigPassed->GetXaxis()->SetBinLabel(5,"L1_J40") ;
+ m_trigPassed->GetXaxis()->SetBinLabel(6,"L1_J50") ;
+ m_trigPassed->GetXaxis()->SetBinLabel(7,"L1_J75") ;
+ m_trigPassed->GetXaxis()->SetBinLabel(8,"L1_J100") ;
+ m_trigPassed->GetXaxis()->SetBinLabel(9,"L1_J350");
+
+ m_trigPassed->GetXaxis()->SetBinLabel(10,"L1_3J10");
+ m_trigPassed->GetXaxis()->SetBinLabel(11,"L1_3J15");
+ m_trigPassed->GetXaxis()->SetBinLabel(12,"L1_3J20");
+ m_trigPassed->GetXaxis()->SetBinLabel(13,"L1_3J50");
+ m_trigPassed->GetXaxis()->SetBinLabel(14,"L1_3J75");
+ m_trigPassed->GetXaxis()->SetBinLabel(15,"L1_4J10");
+ m_trigPassed->GetXaxis()->SetBinLabel(16," L1_4J15");
+ m_trigPassed->GetXaxis()->SetBinLabel(17,"L1_4J30");
+ m_trigPassed->GetXaxis()->SetBinLabel(18,"L1_5J10");
+ m_trigPassed->GetXaxis()->SetBinLabel(19,"L1_5J20");
+
+ m_trigPassed->GetXaxis()->SetBinLabel(20,"EF_mu4_L1J10_matched");
+ m_trigPassed->GetXaxis()->SetBinLabel(21,"EF_e24vh_medium1");
+ m_trigPassed->GetXaxis()->SetBinLabel(22,"EF_mu18_IDTrkNoCut_tight");
+
+ m_trigPassed->GetXaxis()->SetBinLabel(23,"L1_RD0_FILLED");
+
+
+ registerHist(*m_monGr_shift, m_cutflow =
+ TH1F_LW::create("DQ_Cutflow","Number of events passing DQcuts",10,-0.5,9.5));
+
+ m_cutflow->GetXaxis()->SetBinLabel(1,"All");
+ m_cutflow->GetXaxis()->SetBinLabel(2,"Good LAr");
+ m_cutflow->GetXaxis()->SetBinLabel(3,"PV present");
+ m_cutflow->GetXaxis()->SetBinLabel(4,"PV ntrk");
+
+ registerHist(*m_monGr_shift, m_priVtx_trks = TH2F_LW::create("priVtx_trks","Tracks PV",21,-0.5,20.5,21,-0.5,20.5));
+
+ m_priVtx_trks->GetXaxis()->SetTitle("Primary Vertex 0");
+ m_priVtx_trks->GetYaxis()->SetTitle("Primary Vertex 1");
+
+
+
+
+ registerHist(*m_monGr_shift, m_cutflow_jet =
+ TH1F_LW::create("Jet_Cutflow","Number of jets passed DQcuts",10,-0.5,9.5));
+
+ m_cutflow_jet->GetXaxis()->SetBinLabel(1,"All");
+ m_cutflow_jet->GetXaxis()->SetBinLabel(2,"isGoodJet");
+ m_cutflow_jet->GetXaxis()->SetBinLabel(3,"Kinematic Cuts");
+ m_cutflow_jet->GetXaxis()->SetBinLabel(4,"Taggable");
+
+ registerHist(*m_monGr_shift, m_track_selector_eff = TH2F_LW::create("track_selector_eff", "Efficiency of Track Selector Tool;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_track_selector_all = TH2F_LW::create("track_selector_all", "Efficiency of Track Selector Tool;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ //registerHist(*m_monGr_shift, m_track_selector_suspect = TH2F_LW::create("track_selector_suspect", "Efficiency of Track Selector Tool (Suspect Jets)", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ //2D plots
+ //secondary vertex based
+ registerHist(*m_monGr_shift, m_jet_2D_all = TH2F_LW::create("jet_2D_all", "Jet 2D plot (No Cuts);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_jet_2D_good = TH2F_LW::create("jet_2D_good", "Jet 2D plot (Good Jets);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_jet_2D_kinematic = TH2F_LW::create("jet_2D_kinematic", "Jet 2D plot (Kinematic Cuts);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_jet_2D_quality = TH2F_LW::create("jet_2D_quality", "Jet 2D plot (Quality Cuts);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ //registerHist(*m_monGr_shift, m_jet_2D_suspect = TH2F_LW::create("jet_2D_suspect", "Jet 2D plot (Suspect Jets)", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_sv0_tag_pos_rate_2D = TH2F_LW::create("sv0_tag_pos_rate_2D", "SV0 Tag Positive Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_sv0_tag_neg_rate_2D = TH2F_LW::create("sv0_tag_neg_rate_2D", "SV0 Tag Negative Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_sv1_tag_pos_rate_2D = TH2F_LW::create("sv1_tag_pos_rate_2D", "SV1 Tag Positive Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_sv1_tag_neg_rate_2D = TH2F_LW::create("sv1_tag_neg_rate_2D", "SV1 Tag Negative Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_sv2_tag_pos_rate_2D = TH2F_LW::create("sv2_tag_pos_rate_2D", "SV2 Tag Positive Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_sv2_tag_neg_rate_2D = TH2F_LW::create("sv2_tag_neg_rate_2D", "SV2 Tag Negative Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ //impact parameter based
+ registerHist(*m_monGr_shift, m_ip2d_tag_pos_rate_2D = TH2F_LW::create("ip2d_tag_pos_rate_2D", "IP2D Tag Positive Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_ip2d_tag_neg_rate_2D = TH2F_LW::create("ip2d_tag_neg_rate_2D", "IP2D Tag Negative Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_ip3d_tag_pos_rate_2D = TH2F_LW::create("ip3d_tag_pos_rate_2D", "IP3D Tag Positive Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_ip3d_tag_neg_rate_2D = TH2F_LW::create("ip3d_tag_neg_rate_2D", "IP3D Tag Negative Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_ip3d_tag_def_rate_2D = TH2F_LW::create("ip3d_tag_def_rate_2D", "IP3D Tag Default Rate", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ //MV1 based
+ registerHist(*m_monGr_shift, m_mv1_tag_pos_rate_2D = TH2F_LW::create("mv1_tag_pos_rate_2D", "MV1 Tag Positive Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_mv1_tag_neg_rate_2D = TH2F_LW::create("mv1_tag_neg_rate_2D", "MV1 Tag Negative Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_mv1_tag_def_rate_2D = TH2F_LW::create("mv1_tag_def_rate_2D", "MV1 Tag Default Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_mv1_tag_def_rate_2D_LS = TH2F_LW::create("mv1_tag_def_rate_2D_LS", "MV1 Tag Default Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_ip3d_tag_def_rate_2D = TH2F_LW::create("ip3d_tag_def_rate_2D", "IP3D Tag Default Rate", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_sv1ip3d_tag_pos_rate_2D = TH2F_LW::create("sv1ip3d_tag_pos_rate_2D", "SV1+IP3D Tag Positive Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_sv1ip3d_tag_neg_rate_2D = TH2F_LW::create("sv1ip3d_tag_neg_rate_2D", "SV1+IP3D Tag Negative Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_jfcnn_tag_pos_rate_2D = TH2F_LW::create("jfcnn_tag_pos_rate_2D", "JetFitterCOMBNN Tag Positive Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_jfcnn_tag_neg_rate_2D = TH2F_LW::create("jfcnn_tag_neg_rate_2D", "JetFitterCOMBNN Tag Negative Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_shift, m_tracks_all_2D = TH2F_LW::create("tracks_all_2D", "All Tracks", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_pTMin_2D = TH2F_LW::create("tracks_pTMin_2D", "Tracks Failed pTMin Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_d0Max_2D = TH2F_LW::create("tracks_d0Max_2D", "Tracks Failed d0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_z0Max_2D = TH2F_LW::create("tracks_z0Max_2D", "Tracks Failed z0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_sigd0Max_2D = TH2F_LW::create("tracks_sigd0Max_2D", "Tracks Failed sigd0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_sigz0Max_2D = TH2F_LW::create("tracks_sigz0Max_2D", "Tracks Failed sigz0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_etaMax_2D = TH2F_LW::create("tracks_etaMax_2D", "Tracks Failed etaMax Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_nHitBLayer_2D = TH2F_LW::create("tracks_nHitBLayer_2D", "Tracks Failed nHitBLayer Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_deadBLayer_2D = TH2F_LW::create("tracks_deadBLayer_2D", "Tracks Failed deadBLayer Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_nHitPix_2D = TH2F_LW::create("tracks_nHitPix_2D", "Tracks Failed nHitPix Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_nHitSct_2D = TH2F_LW::create("tracks_nHitSct_2D", "Tracks Failed nHitSct Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_nHitSi_2D = TH2F_LW::create("tracks_nHitSi_2D", "Tracks Failed nHitSi Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_nHitTrt_2D = TH2F_LW::create("tracks_nHitTrt_2D", "Tracks Failed nHitTrt Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_nHitTrtHighE_2D = TH2F_LW::create("tracks_nHitTrtHighE_2D", "Tracks Failed nHitTrtHighE Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_fitChi2_2D = TH2F_LW::create("tracks_fitChi2_2D", "Tracks Failed fitChi2 Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_fitProb_2D = TH2F_LW::create("tracks_fitProb_2D", "Tracks Failed fitProb Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_shift, m_tracks_fitChi2OnNdfMax_2D = TH2F_LW::create("tracks_fitChi2OnNdfMax_2D", "Tracks Failed fitChi2OnNdfMax Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+
+ /*
+ Starting to register LowStat histograms:
+ */
+ if ( newRun || newLowStatInterval ) {
+ registerHist(*m_monGr_LowStat, m_tracks_all_2D_LS = TH2F_LW::create("tracks_all_2D_LS", "All Tracks;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_pTMin_2D_LS = TH2F_LW::create("tracks_pTMin_2D_LS", "Tracks Failed pTMin Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_d0Max_2D_LS = TH2F_LW::create("tracks_d0Max_2D_LS", "Tracks Failed d0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_z0Max_2D_LS = TH2F_LW::create("tracks_z0Max_2D_LS", "Tracks Failed z0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_sigd0Max_2D_LS = TH2F_LW::create("tracks_sigd0Max_2D_LS", "Tracks Failed sigd0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_sigz0Max_2D_LS = TH2F_LW::create("tracks_sigz0Max_2D_LS", "Tracks Failed sigz0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_etaMax_2D_LS = TH2F_LW::create("tracks_etaMax_2D_LS", "Tracks Failed etaMax Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_nHitBLayer_2D_LS = TH2F_LW::create("tracks_nHitBLayer_2D_LS", "Tracks Failed nHitBLayer Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_deadBLayer_2D_LS = TH2F_LW::create("tracks_deadBLayer_2D_LS", "Tracks Failed deadBLayer Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_nHitPix_2D_LS = TH2F_LW::create("tracks_nHitPix_2D_LS", "Tracks Failed nHitPix Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_nHitSct_2D_LS = TH2F_LW::create("tracks_nHitSct_2D_LS", "Tracks Failed nHitSct Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_nHitSi_2D_LS = TH2F_LW::create("tracks_nHitSi_2D_LS", "Tracks Failed nHitSi Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_nHitTrt_2D_LS = TH2F_LW::create("tracks_nHitTrt_2D_LS", "Tracks Failed nHitTrt Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_nHitTrtHighE_2D_LS = TH2F_LW::create("tracks_nHitTrtHighE_2D_LS", "Tracks Failed nHitTrtHighE Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_fitChi2_2D_LS = TH2F_LW::create("tracks_fitChi2_2D_LS", "Tracks Failed fitChi2 Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_fitProb_2D_LS = TH2F_LW::create("tracks_fitProb_2D_LS", "Tracks Failed fitProb Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_tracks_fitChi2OnNdfMax_2D_LS = TH2F_LW::create("tracks_fitChi2OnNdfMax_2D_LS", "Tracks Failed fitChi2OnNdfMax Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+
+ registerHist(*m_monGr_LowStat, m_ip3d_tag_def_rate_2D_LS = TH2F_LW::create("ip3d_tag_def_rate_2D_LS", "IP3D Tag Default Rate", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_jet_2D_kinematic_LS = TH2F_LW::create("jet_2D_kinematic_LS", "Jet 2D plot (Kinematic Cuts);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_track_selector_eff_LS = TH2F_LW::create("track_selector_eff_LS", "Efficiency of Track Selector Tool;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ registerHist(*m_monGr_LowStat, m_track_selector_all_LS = TH2F_LW::create("track_selector_all_LS", "Efficiency of Track Selector Tool;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
+ }
+
+ /*
+ Ended registering LowStat histograms
+ */
+
+ m_histogramsCreated = true;
+
+ return StatusCode::SUCCESS;
+}
+
+
+//** --------------------------------------------------------------------------------------------------------------- **//
+
+
+StatusCode JetTagMonitoring::fillHistograms() {
+
+ msg(MSG::DEBUG)<< "fillHistograms()" << endreq;
+
+ if (!m_histogramsCreated)
+ return StatusCode::SUCCESS;
+
+ if (m_switch_off)
+ return StatusCode::SUCCESS;
+
+ m_cutflow->Fill(0.);
+
+ const xAOD::EventInfo* thisEventInfo;
+ if (evtStore()->retrieve(thisEventInfo).isFailure())
+ msg(MSG::WARNING)<< "Cannot retrieve EventInfo" << endreq;
+
+ m_lumiBlockNum = thisEventInfo->lumiBlock();
+
+ msg(MSG::DEBUG) << "Lumiblock ID: " << m_lumiBlockNum << endreq;
+
+ ////////////////////////////////
+ //* skip events with bad LAr *//
+ ////////////////////////////////
+
+ if ( thisEventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr, LArEventBitInfo::BADFEBS) ) {
+ msg(MSG::DEBUG) << "Bad LAr event: True" << endreq;
+ return StatusCode::SUCCESS;
+ }
+
+ m_cutflow->Fill(1.);
+
+
+
+ ///////////////////////////////
+ //* Trigger container *//
+ ///////////////////////////////
+
+ msg(MSG::DEBUG) << "TrigDecTool: " << m_trigDecTool << endreq;
+
+ if (m_use_trigdectool && m_trigDecTool != 0) {
+ if (m_trigDecTool->isPassed("L1_J10")) m_trigPassed->Fill(0.);
+ if (m_trigDecTool->isPassed("L1_J15")) m_trigPassed->Fill(1.);
+ if (m_trigDecTool->isPassed("L1_J20")) m_trigPassed->Fill(2.);
+ if (m_trigDecTool->isPassed("L1_J30")) m_trigPassed->Fill(3.);
+ if (m_trigDecTool->isPassed("L1_J40")) m_trigPassed->Fill(4.);
+ if (m_trigDecTool->isPassed("L1_J50")) m_trigPassed->Fill(5.);
+ if (m_trigDecTool->isPassed("L1_J75")) m_trigPassed->Fill(6.);
+ if (m_trigDecTool->isPassed("L1_J100")) m_trigPassed->Fill(7.);
+ if (m_trigDecTool->isPassed("L1_J350")) m_trigPassed->Fill(8.);
+ if (m_trigDecTool->isPassed("L1_3J10")) m_trigPassed->Fill(9.);
+ if (m_trigDecTool->isPassed("L1_3J15")) m_trigPassed->Fill(10.);
+ if (m_trigDecTool->isPassed("L1_3J20")) m_trigPassed->Fill(11.);
+ if (m_trigDecTool->isPassed("L1_3J50")) m_trigPassed->Fill(12.);
+ if (m_trigDecTool->isPassed("L1_3J75")) m_trigPassed->Fill(13.);
+ if (m_trigDecTool->isPassed("L1_4J10")) m_trigPassed->Fill(14.);
+ if (m_trigDecTool->isPassed("L1_4J15")) m_trigPassed->Fill(15.);
+ if (m_trigDecTool->isPassed("L1_4J30")) m_trigPassed->Fill(16.);
+ if (m_trigDecTool->isPassed("L1_5J10")) m_trigPassed->Fill(17.);
+ if (m_trigDecTool->isPassed("L1_5J20")) m_trigPassed->Fill(18.);
+
+
+ if (m_trigDecTool->isPassed("EF_mu4_L1J10_matched")) m_trigPassed->Fill(19.);
+ if (m_trigDecTool->isPassed("EF_e24vh_medium1")) m_trigPassed->Fill(20.);
+ if (m_trigDecTool->isPassed("EF_mu18_IDTrkNoCut_tight")) m_trigPassed->Fill(21.);
+
+ if (m_trigDecTool->isPassed("L1_RD0_FILLED")) m_trigPassed->Fill(22.);
+ }
+
+ //////////////////////
+ //* Primary vertex *//
+ //////////////////////
+
+ unsigned int npv = 0, npv_trk = 0, nsv_trk = 0;
+ double xpv = 0., ypv = 0., zpv = 0.;
+
+ const DataHandle<VxContainer> vxContainer;
+ bool foundPrimaryVtx = retrieveCollection(m_storeGate, vxContainer, m_primaryVertexName);
+
+ if (!foundPrimaryVtx) {
+
+ msg(MSG::WARNING) << "Unable to retrieve \"" << m_primaryVertexName << "\" from StoreGate" << endreq;
+
+ return StatusCode::SUCCESS;
+ }
+
+ msg(MSG::DEBUG)<< "VxContainer \"" << m_primaryVertexName << "\" found with " << vxContainer->size() << " entries" << endreq;
+
+ npv = vxContainer->size();
+ m_global_nPrimVtx->Fill((float)npv);
+
+ if (vxContainer->size() < 1) {
+ msg(MSG::WARNING) << "No primary vertices reconstructed" << endreq;
+ return StatusCode::SUCCESS;
+ }
+
+ m_cutflow->Fill(2.);
+
+ m_priVtx = vxContainer->at(0);
+
+ npv_trk = m_priVtx->vxTrackAtVertex()->size();
+
+ msg(MSG::DEBUG) << "PV tracks: " << npv_trk << endreq;
+
+ const Trk::RecVertex& primaryRecVertex = m_priVtx->recVertex();
+
+ xpv = primaryRecVertex.position().x();
+ ypv = primaryRecVertex.position().y();
+ zpv = primaryRecVertex.position().z();
+
+ m_global_xPrimVtx->Fill(xpv);
+ m_global_yPrimVtx->Fill(ypv);
+ m_global_zPrimVtx->Fill(zpv);
+
+ msg(MSG::DEBUG)<< "primary vertex: x = " << xpv << ", y = " << ypv << ", z = " << zpv << endreq;
+
+ if (xpv == 0 && ypv == 0 && zpv == 0)
+ msg(MSG::WARNING) << "Primary Vertex is (0,0,0)" << endreq;
+
+ /* store the number of tracks of the second PV candidate, if any */
+ if ( vxContainer->size() > 1 ) {
+ nsv_trk = vxContainer->at(1)->vxTrackAtVertex()->size();
+ }
+
+ m_priVtx_trks->Fill(npv_trk, nsv_trk);
+
+ // check first PV > 4 tracks, if not, bail
+ if ( npv_trk < m_pri_vtx_trk_min_cut )
+ return StatusCode::SUCCESS;
+
+ m_cutflow->Fill(3.);
+
+// double vtxChiSq = primaryRecVertex.fitQuality().chiSquared();
+// int vtxNDoF = primaryRecVertex.fitQuality().numberDoF();
+
+// double vtxProb = vtxChiSq / vtxNDoF;
+
+ /* Fill Jet-based histograms */
+
+ fillJetHistograms();
+
+ ///////////////////////////////
+ //* TrackParticle container *//
+ ///////////////////////////////
+
+ const DataHandle<xAOD::TrackParticleContainer> trackParticles;
+ bool foundTrackPartColl = retrieveCollection(m_storeGate, trackParticles, m_trackParticleName);
+
+ if (!foundTrackPartColl) {
+
+ msg(MSG::WARNING) << "Unable to retrieve \"" << m_trackParticleName << "\" from StoreGate" << endreq;
+
+ return StatusCode::SUCCESS;
+
+ }
+
+ msg(MSG::DEBUG) << "TrackParticleContainer \"" << m_trackParticleName << "\" found with " << trackParticles->size() << " entries" << endreq;
+
+ xAOD::TrackParticleContainer::const_iterator trackParticleItr = trackParticles->begin();
+ xAOD::TrackParticleContainer::const_iterator trackParticleEnd = trackParticles->end();
+
+ // New for Release 19: summary information is filled by reference, with a boolean Pass/Fail check...
+
+ uint8_t nPixHits = 0;
+ uint8_t nSCTHits = 0;
+ uint8_t nSiHits = 0;
+ uint8_t nBLayerHits = 0;
+ uint8_t nTRTHits = 0;
+
+ for ( ; trackParticleItr != trackParticleEnd; trackParticleItr++) {
+
+ if ((*trackParticleItr)->summaryValue(nBLayerHits, xAOD::numberOfBLayerHits)) { m_global_BLayerHits->Fill((float) nBLayerHits); }
+ if ((*trackParticleItr)->summaryValue(nPixHits, xAOD::numberOfPixelHits)) { m_global_PixelHits->Fill((float) nPixHits); }
+ if ((*trackParticleItr)->summaryValue(nSCTHits, xAOD::numberOfSCTHits)) { m_global_SCTHits->Fill((float) nSCTHits); }
+ if ((*trackParticleItr)->summaryValue(nTRTHits, xAOD::numberOfTRTHits)) { m_global_TRTHits->Fill((float) nTRTHits); }
+
+ // too complicated to set up a check at this point... thank you framework!
+ nSiHits = nPixHits + nSCTHits;
+ m_global_SiHits->Fill((float)nSiHits);
+ nSiHits = 0; // clean up value for next round...
+ }
+
+ m_trackParticle_n->Fill((*trackParticles).size());
+
+ msg(MSG::DEBUG) << "end of fillHistograms()" << endreq;
+
+ return StatusCode::SUCCESS;
+}
+
+
+bool JetTagMonitoring::applyKinematicCuts(const xAOD::Jet *jet) {
+
+ msg(MSG::DEBUG) << "applyKinematicCuts()" << endreq;
+
+ //* get jet basic kinematics *//
+ CLHEP::HepLorentzVector p4(jet->px(),jet->py(),jet->pz(),jet->e());
+
+ m_jet_eta->Fill(p4.pseudoRapidity());
+ m_jet_phi->Fill(p4.phi());
+ m_jet_et->Fill(p4.et());
+
+ msg(MSG::DEBUG) << "BJet kinematics: eta = " << p4.pseudoRapidity()
+ << ", phi= " << p4.phi() << ", pT= " << p4.perp()
+ << endreq;
+
+
+ // kinematic cuts defined as properties
+ if ( jet->pt() < m_jet_pt_cut || fabs(jet->eta()) > m_jet_eta_cut )
+ return false;
+
+ return true;
+}
+
+
+JetTagMonitoring::Jet_t JetTagMonitoring::applyQualityCuts(const xAOD::Jet *jet) {
+
+ msg(MSG::DEBUG) << "in applyQualityCuts()" << endreq;
+
+ /* if TrackSelector not used, return true */
+ if ( ! m_use_trackselector ) {
+ msg(MSG::DEBUG) << "Not running track selection" << endreq;
+ return goodJet;
+ }
+
+ msg(MSG::DEBUG) << "Running track selection" << endreq;
+
+ unsigned int nTrk = 0, nTrk_JetProb = 0;
+
+ // std::vector<InDet::TrackStateOnBLayerInfo> bInfo;
+ m_track_selector_all->Fill(jet->eta(), jet->phi(), 1.);
+ m_track_selector_all_LS->Fill(jet->eta(), jet->phi(), 1.);
+ //Work around, but compared to _all not needed.
+ // m_track_selector_eff->Fill(jet->eta(), jet->phi(), 1.);
+
+ m_trackSelectorTool->primaryVertex(m_priVtx->recVertex().position());
+ m_trackSelectorTool->prepare();
+
+ std::vector<const xAOD::IParticle*> trackVector = jet->getAssociatedObjects<xAOD::IParticle>(xAOD::JetAttribute::GhostTrack);
+
+ bool isSuspectJet = false;
+
+ std::vector<const xAOD::IParticle*>::const_iterator trkItr;
+
+ for ( trkItr = trackVector.begin(); trkItr != trackVector.end() ; trkItr++ ) {
+
+ const xAOD::TrackParticle* trackPart = dynamic_cast<const xAOD::TrackParticle*>(*trkItr);
+
+ double trk_eta = trackPart->eta();
+ double trk_phi = trackPart->phi();
+
+ m_tracks_all_2D->Fill(trk_eta, trk_phi, 1.);
+ m_tracks_all_2D_LS->Fill(trk_eta, trk_phi, 1.);
+
+ if ( m_trackSelectorTool->selectTrack(trackPart) ) {
+
+ nTrk++;
+
+ double trk_d0 = trackPart->d0();
+
+ if (trk_d0 > m_trk_d0_min_cut && trk_d0 < m_trk_d0_max_cut)
+ nTrk_JetProb++;
+
+ } else {
+ const std::bitset<16> failedCuts = m_trackSelectorTool->currentTrackpassedCuts();
+ fillBadTrackBits(failedCuts, trk_eta, trk_phi);
+
+ if ( failedCuts[deadBLayer] || failedCuts[nHitBLayer] || failedCuts[nHitSi] )
+ isSuspectJet = true;
+ }
+
+ }
+
+
+ msg(MSG::DEBUG) << "Good tracks: " << nTrk << endreq;
+
+ if ( nTrk_JetProb > m_trk_n ) {
+
+ const xAOD::BTagging* btag = jet->btagging();
+
+ // get JetFitter b probability
+ double myTagValue = btag->JetFitter_pb();
+ m_tag_jetprob_w->Fill(myTagValue );
+
+ }
+ if ( nTrk < m_trk_n )
+ return badJet;
+
+ m_track_selector_eff_LS->Fill(jet->eta(), jet->phi(), 1.);
+
+ if ( isSuspectJet )
+ return suspectJet;
+
+ return goodJet;
+
+}
+
+
+StatusCode JetTagMonitoring::procHistograms() {
+
+ msg(MSG::DEBUG) << "in procHistograms()" << endreq;
+
+ /* Finalize the histograms */
+ if ( endOfRun && m_histogramsCreated ) {
+
+ m_track_selector_eff->getROOTHist()->Divide(m_track_selector_all->getROOTHist(),m_tracks_all_2D->getROOTHist());
+ }
+ msg(MSG::DEBUG) << "Exiting from procHistograms()" << endreq;
+ return StatusCode::SUCCESS;
+}
+
+
+void JetTagMonitoring::fillJetHistograms() {
+
+ msg(MSG::DEBUG) << "in fillJetHistograms()" << endreq;
+
+ /////////////////////
+ //* Jet container *//
+ /////////////////////
+
+ const DataHandle<xAOD::JetContainer> jets;
+ bool foundJetColl = retrieveCollection(m_storeGate, jets, m_jetName);
+
+ if (!foundJetColl) {
+
+ msg(MSG::WARNING) << "Unable to retrieve \"" << m_jetName << "\" from StoreGate" << endreq;
+
+ return;
+
+ }
+
+ msg(MSG::DEBUG) << "JetContainer \"" << m_jetName << "\" found with " << jets->size() << " entries" << endreq;
+
+ xAOD::JetContainer::const_iterator jetItr = jets->begin();
+ xAOD::JetContainer::const_iterator jetEnd = jets->end();
+
+ m_jet_n->Fill((*jets).size());
+
+ for ( ; jetItr != jetEnd; jetItr++) {
+
+ m_cutflow_jet->Fill(0.);
+
+ m_jet_2D_all->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+
+ if( !isGoodJet(*jetItr) ) continue;
+
+ m_cutflow_jet->Fill(1.);
+
+ m_jet_2D_good->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+
+ if ( !applyKinematicCuts(*jetItr) ) continue;
+
+ m_jet_2D_kinematic->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ m_jet_2D_kinematic_LS->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+
+ m_cutflow_jet->Fill(2.);
+
+ //* get information about Track Constituents *//
+ fillTrackInJetHistograms(*jetItr);
+
+ const xAOD::BTagging* btag =(*jetItr)->btagging();
+
+ double ip3d = btag->IP3D_pb();
+ double sv0 = btag->SV0_significance3D();
+ double sv1 = btag->SV1_pb();
+ double combNN = btag->JetFitter_pb();
+ double mv1 = btag->MV1_discriminant();
+
+ /* fill the 2D SV0 rate */
+ if ( sv0 > m_sv0_weight_cut ) {
+ m_sv0_tag_pos_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ } else {
+ m_sv0_tag_neg_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ }
+
+ /* fill the 2D SV1 rate */
+ if ( sv1 > m_sv1_weight_cut ) {
+ m_sv1_tag_pos_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ } else {
+ m_sv1_tag_neg_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ }
+
+ /* fill the 2D IP3D rate */
+ if ( ip3d > m_ip3d_weight_cut ) {
+ m_ip3d_tag_pos_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ } else if ( ip3d < -20 ) {
+ m_ip3d_tag_def_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ m_ip3d_tag_def_rate_2D_LS->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ } else {
+ m_ip3d_tag_neg_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ }
+
+ /* fill the 2D MV1 rate */
+ if ( mv1 > m_mv1_weight_cut ) {
+ m_mv1_tag_pos_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ } else if ( mv1 <= 0. ) {
+ m_mv1_tag_def_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ m_mv1_tag_def_rate_2D_LS->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ } else {
+ m_mv1_tag_neg_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ }
+
+ /* fill the 2D JetFitterCOMBNN rate */
+ if ( combNN > m_jfcnn_weight_cut ) {
+ m_jfcnn_tag_pos_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ } else {
+ m_jfcnn_tag_neg_rate_2D->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
+ }
+
+ msg(MSG::DEBUG)<< "btagging weights: \n"
+
+ << " SV0: " << sv0 << " SV1: " << sv1 << "\n"
+ << " IP3D: " << ip3d << "\n"
+ << " JetFitterCOMBNN: " << combNN << "\n"
+ << " MV1: "<< mv1 <<endreq;
+
+ Jet_t quality = applyQualityCuts(*jetItr);
+
+ if ( m_do_cuts && quality == badJet ) continue;
+
+ m_cutflow_jet->Fill(3.);
+
+ if ( quality == goodJet )
+ fillGoodJetHistos(*jetItr);
+ //else if ( quality == suspectJet )
+ // fillSuspectJetHistos(*jetItr);
+
+ //* MOAR PLOTS! *//
+ fillDetailedHistograms(*jetItr);
+
+ //* get information about Electron Constituents *//
+ //fillElectronHistograms(*jetItr);
+
+ //* get information about Muon Constituents *//
+ //fillMuonHistograms(*jetItr);
+
+ }
+
+
+ return;
+}
+
+/* Soft Electron tagger no longer maintained
+void JetTagMonitoring::fillElectronHistograms(const xAOD::Jet *jet) {
+
+ // get information about Electron Constituents //
+
+ msg(MSG::DEBUG) << "in fillElectronHistograms()" << endreq;
+
+ int nElInJet = 0;
+
+ const Analysis::ElectronAssociation *elInJet = jet->getAssociation<Analysis::ElectronAssociation>("Electrons");
+
+ // loop over electrons in a jet //
+ if (elInJet) {
+ nElInJet = elInJet->size();
+
+ Navigable<ElectronContainer,double>::object_iter elItr = elInJet->begin();
+ for ( ; elItr != elInJet->end(); ++elItr) {
+ m_jet_electrons_pt->Fill((*elItr)->pt()/1000.);
+ }
+ }
+
+ m_jet_electrons_n->Fill((float)nElInJet);
+
+ return;
+}
+*/
+
+/* Soft Muon tagger no longer maintained
+void JetTagMonitoring::fillMuonHistograms(const xAOD::Jet *jet) {
+
+ msg(MSG::DEBUG) << "in fillMuonHistograms()" << endreq;
+
+ // get information about Muon Constituents //
+ int nMuInJet = 0;
+
+ const Analysis::MuonAssociation *muInJet = jet->getAssociation<Analysis::MuonAssociation>("Muons");
+
+ // loop over muons in a jet //
+ if (muInJet) {
+
+ nMuInJet = muInJet->size();
+
+ Navigable<Analysis::MuonContainer,double>::object_iter muItr = muInJet->begin();
+ for ( ; muItr != muInJet->end(); ++muItr) {
+ m_jet_muons_pt->Fill((*muItr)->pt()/1000.);
+ }
+ }
+
+
+ m_jet_muons_n->Fill((float)nMuInJet);
+
+ return;
+}
+*/
+
+void JetTagMonitoring::fillTrackInJetHistograms(const xAOD::Jet *jet) {
+
+ msg(MSG::DEBUG) << "in fillInJetTrackHistograms()" << endreq;
+
+ //* get information about Track Constituents *//
+ int nTrkInJet = 0;
+
+ std::vector<const xAOD::IParticle*> trackVector = jet->getAssociatedObjects<xAOD::IParticle>(xAOD::JetAttribute::GhostTrack);
+
+ std::vector<const xAOD::IParticle*>::const_iterator trkItr;
+
+ nTrkInJet = trackVector.size();
+ msg(MSG::DEBUG) << "examining " << nTrkInJet << " tracks." << endreq;
+
+ // loop over tracks in a jet //
+ for ( trkItr = trackVector.begin(); trkItr != trackVector.end() ; trkItr++ ) {
+
+ const xAOD::TrackParticle* trackPart = dynamic_cast<const xAOD::TrackParticle*>(*trkItr);
+
+ uint8_t nBLayerHits = 0;
+ uint8_t nPixHits = 0;
+ uint8_t nSCTHits = 0;
+
+ m_jet_tracks_pt->Fill(trackPart->pt()/1000.);
+ m_jet_tracks_eta->Fill(trackPart->eta());
+ m_jet_tracks_phi->Fill(trackPart->phi());
+
+ if (trackPart->summaryValue(nBLayerHits, xAOD::numberOfBLayerHits)) { m_jet_tracks_BLayerHits->Fill((float) nBLayerHits); }
+ if (trackPart->summaryValue(nPixHits, xAOD::numberOfPixelHits)) { m_jet_tracks_PixelHits->Fill((float) nPixHits); }
+ if (trackPart->summaryValue(nSCTHits, xAOD::numberOfSCTHits)) { m_jet_tracks_SCTHits->Fill((float) nSCTHits); }
+
+ }
+
+ m_jet_tracks_n->Fill((float)nTrkInJet);
+
+ return;
+}
+
+void JetTagMonitoring::fillDetailedHistograms(const xAOD::Jet *jet) {
+
+ msg(MSG::DEBUG) << "in fillDetailedHistograms()" << endreq;
+
+ //* get detailed information *//
+ const xAOD::BTagging* btag = jet->btagging();
+
+
+ //* detailed information for impact parameter-based informations *//
+ unsigned int ntrk = btag->nIP3D_TrackParticles(); // number of tracks used for tagging in the jet
+ double pb = btag->IP3D_pb(); // b likelihood
+ double pu = btag->IP3D_pu(); // u likelihood
+
+ m_tag_ip3d_n->Fill((float)ntrk);
+ m_tag_ip3d_b->Fill(pb);
+ m_tag_ip3d_u->Fill(pu);
+
+ msg(MSG::VERBOSE) << "InfoBase for IP3D: #tracks = " << ntrk
+ << ", Pb = " << pb << ", Pu = " << pu << endreq;
+
+ return;
+}
+
+
+void JetTagMonitoring::fillBadTrackBits(const std::bitset<16> failedCuts, double eta, double phi) {
+
+ if ( failedCuts[pTMin] ) m_tracks_pTMin_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[d0Max] ) m_tracks_d0Max_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[z0Max] ) m_tracks_z0Max_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[sigd0Max] ) m_tracks_sigd0Max_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[sigz0Max] ) m_tracks_sigz0Max_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[etaMax] ) m_tracks_etaMax_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitBLayer] ) m_tracks_nHitBLayer_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[deadBLayer] ) m_tracks_deadBLayer_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitPix] ) m_tracks_nHitPix_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitSct] ) m_tracks_nHitSct_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitSi] ) m_tracks_nHitSi_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitTrt] ) m_tracks_nHitTrt_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitTrtHighE] ) m_tracks_nHitTrtHighE_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[fitChi2] ) m_tracks_fitChi2_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[fitProb] ) m_tracks_fitProb_2D->Fill(eta, phi, 1.);
+ if ( failedCuts[fitChi2OnNdfMax] ) m_tracks_fitChi2OnNdfMax_2D->Fill(eta, phi, 1.);
+
+
+ if ( failedCuts[pTMin] ) m_tracks_pTMin_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[d0Max] ) m_tracks_d0Max_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[z0Max] ) m_tracks_z0Max_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[sigd0Max] ) m_tracks_sigd0Max_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[sigz0Max] ) m_tracks_sigz0Max_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[etaMax] ) m_tracks_etaMax_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitBLayer] ) m_tracks_nHitBLayer_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[deadBLayer] ) m_tracks_deadBLayer_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitPix] ) m_tracks_nHitPix_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitSct] ) m_tracks_nHitSct_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitSi] ) m_tracks_nHitSi_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitTrt] ) m_tracks_nHitTrt_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[nHitTrtHighE] ) m_tracks_nHitTrtHighE_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[fitChi2] ) m_tracks_fitChi2_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[fitProb] ) m_tracks_fitProb_2D_LS->Fill(eta, phi, 1.);
+ if ( failedCuts[fitChi2OnNdfMax] ) m_tracks_fitChi2OnNdfMax_2D_LS->Fill(eta, phi, 1.);
+
+
+ return;
+
+}
+
+void JetTagMonitoring::fillGoodJetHistos(const xAOD::Jet *jet) {
+
+ m_jet_2D_quality->Fill(jet->eta(), jet->phi(), 1.);
+
+ const xAOD::BTagging* btag = jet->btagging();
+
+ double ip3d = btag->IP3D_pb();
+ double sv0 = btag->SV0_significance3D();
+ double sv1 = btag->SV1_pb();
+ double combNN = btag->JetFitter_pb();
+ double mv1 = btag->MV1_discriminant();
+
+ m_tag_ip3d_w->Fill(ip3d);
+ m_tag_mv1_w->Fill(mv1);
+ m_tag_sv0_w->Fill(sv0);
+ m_tag_sv1_w->Fill(sv1);
+ m_tag_jfcnn_w->Fill(combNN);
+
+ return;
+
+}
+
+/* should mimick as close as possible the same function from Reconstruction/Jet/JetMonitoring/src/JetRecMonToolBase.cxx */
+
+bool JetTagMonitoring::isGoodJet(const xAOD::Jet *jet){
+
+ if (msgLvl(MSG::DEBUG))
+ msg(MSG::DEBUG) << "in dq cleaning cuts JetTagMon" << endreq;
+
+ bool pass_cuts = false;
+
+ float jetQuality = jet->getAttribute<float>(xAOD::JetAttribute::LArQuality);
+ float jetTime = jet->getAttribute<float>(xAOD::JetAttribute::Timing);
+ float hecq = jet->getAttribute<float>(xAOD::JetAttribute::HECQuality);
+ float negE = jet->getAttribute<float>(xAOD::JetAttribute::NegativeE);
+ float chf = jet->getAttribute<float>(xAOD::JetAttribute::SumPtTrkPt1000)/jet->pt();
+ float emf = jet->getAttribute<float>(xAOD::JetAttribute::EMFrac);
+ float hecf = jet->getAttribute<float>(xAOD::JetAttribute::HECFrac);
+ //int SamplingMax = CaloSampling::Unknown;
+ float fracSamplingMax = jet->getAttribute<float>(xAOD::JetAttribute::FracSamplingMax);
+
+ if (
+ !(
+ (hecf>0.5 && fabs(hecq)>0.5) || (fabs(negE) > 60*CLHEP::GeV) ||
+ (emf>0.95 && fabs(jetQuality)>0.8 && fabs(jet->eta()) < 2.8) ||
+ //(n90<=5 && hecf>0.8) || (hecf>0.5 && fabs(jetQuality)>0.5) || (emf<0.05) ||
+ (fabs(jetTime)>25) ||
+ (emf<0.05 && chf<0.05 && fabs(jet->eta())<2) ||
+ (emf<0.05 && fabs(jet->eta())>= 2) ||
+ (fracSamplingMax>0.99 && fabs(jet->eta())<2)
+ )
+ ){
+ pass_cuts = true;
+ }
+
+ return pass_cuts;
+
+}
+
+/*
+void JetTagMonitoring::fillSuspectJetHistos(const xAOD::Jet *jet) {
+
+ float sv0 = jet->getFlavourTagWeight("SV0");
+ float comb = jet->getFlavourTagWeight(); // combination of IP3D and SV1
+ float combNN = jet->getFlavourTagWeight("JetFitterCOMBNN");
+
+ m_jet_2D_suspect->Fill(jet->eta(), jet->phi(), 1.);
+
+ m_track_selector_suspect->Fill(jet->eta(), jet->phi(), 1.);
+
+ m_tag_sv0_w_sj->Fill(sv0);
+ m_tag_comb_w_sj->Fill(comb);
+ m_tag_jfcnn_w_sj->Fill(combNN);
+
+ return;
+
+}
+
+
+void JetTagMonitoring::fillBadZone(int zone, double ip3d) {
+
+ if( zone == 1 ) {
+ m_tag_ip3d_w_DMZ2_x1->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ2_x2->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ2_x4->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ2_x8->Fill(ip3d, 1.);
+
+ m_tag_ip3d_w_DMZ3_x1->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ3_x2->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ3_x4->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ3_x8->Fill(ip3d, 1.);
+ }
+ else if ( zone == 2 ) {
+ m_tag_ip3d_w_DMZ2_x1->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ2_x2->Fill(ip3d, 2.);
+ m_tag_ip3d_w_DMZ2_x4->Fill(ip3d, 4.);
+ m_tag_ip3d_w_DMZ2_x8->Fill(ip3d, 8.);
+
+ m_tag_ip3d_w_DMZ3_x1->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ3_x2->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ3_x4->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ3_x8->Fill(ip3d, 1.);
+ }
+ else if ( zone == 3 ) {
+ m_tag_ip3d_w_DMZ2_x1->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ2_x2->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ2_x4->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ2_x8->Fill(ip3d, 1.);
+
+ m_tag_ip3d_w_DMZ3_x1->Fill(ip3d, 1.);
+ m_tag_ip3d_w_DMZ3_x2->Fill(ip3d, 2.);
+ m_tag_ip3d_w_DMZ3_x4->Fill(ip3d, 4.);
+ m_tag_ip3d_w_DMZ3_x8->Fill(ip3d, 8.);
+ }
+
+ return;
+
+}
+*/
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/src/components/JetTagMonitoring_entries.cxx b/PhysicsAnalysis/JetTagging/JetTagMonitoring/src/components/JetTagMonitoring_entries.cxx
new file mode 100755
index 00000000000..0b1cb9e4a01
--- /dev/null
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/src/components/JetTagMonitoring_entries.cxx
@@ -0,0 +1,10 @@
+#include "GaudiKernel/DeclareFactoryEntries.h"
+#include "JetTagMonitoring/JetTagMonitoring.h"
+
+DECLARE_TOOL_FACTORY( JetTagMonitoring )
+
+DECLARE_FACTORY_ENTRIES( JetTagMonitoring ) {
+
+ DECLARE_ALGTOOL( JetTagMonitoring )
+
+}
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/src/components/JetTagMonitoring_load.cxx b/PhysicsAnalysis/JetTagging/JetTagMonitoring/src/components/JetTagMonitoring_load.cxx
new file mode 100755
index 00000000000..e6e758a9093
--- /dev/null
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/src/components/JetTagMonitoring_load.cxx
@@ -0,0 +1,3 @@
+#include "GaudiKernel/LoadFactoryEntries.h"
+
+LOAD_FACTORY_ENTRIES( JetTagMonitoring )
--
GitLab