ATLAS Offline Software
JetTagMonitoring.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "xAODJet/JetAttributes.h"
6 #include "xAODBTagging/BTagging.h"
7 #include "xAODBTagging/BTaggingUtilities.h"
8 
9 #include "JetTagMonitoring.h"
10 
11 // #include "xAODTracking/TrackParticle.h"
12 // #include "xAODTracking/Vertex.h"
13 
14 #include "TrigDecisionTool/TrigDecisionTool.h" // added by SARA
15 #include "TrkParticleBase/LinkToTrackParticleBase.h"
16 #include "TrkVertexFitterInterfaces/ITrackToVertexIPEstimator.h"
17 #include "VxSecVertex/VxSecVKalVertexInfo.h"
18 #include "VxSecVertex/VxSecVertexInfo.h"
19 
20 #include "LArRecEvent/LArEventBitInfo.h"
21 
22 #include "LWHists/LWHist.h"
23 #include "LWHists/TH1F_LW.h"
24 #include "LWHists/TH2F_LW.h"
25 
26 #include "GaudiKernel/SystemOfUnits.h"
27 
28 #include "TH1F.h"
29 #include "TH2F.h"
30 #include "TMath.h"
31 #include "TEfficiency.h"
32 
33 #include <vector>
34 #include <string>
35 #include <sstream>
36 
37 //** --------------------------------------------------------------------------------------------------------------- **//
38 
39 
40 JetTagMonitoring::JetTagMonitoring(const std::string & type, const std::string & name, const IInterface* parent) :
41  ManagedMonitorToolBase(type, name, parent),
42  m_histogramsCreated(false),
43  m_jetBtagKey(this, "JetBtagKey", m_jetName.key()+".btaggingLink"),
44  m_switch_off(false)
45 {
46  declareProperty("DQcuts", m_do_cuts = true);
47 
48  declareProperty("PriVtxTrkMinCut", m_pri_vtx_trk_min_cut = 4 );
49  declareProperty("D0_min_cuts", m_trk_d0_min_cut = 0);
50  declareProperty("D0_max_cuts", m_trk_d0_max_cut = 1);
51  declareProperty("JetPt_cuts", m_jet_pt_cut = 15.0); // in GeV
52  declareProperty("JetEta_cuts", m_jet_eta_cut = 2.5);
53  declareProperty("nTrk_cuts", m_trk_n = 1);
54  declareProperty("SV1IP3D_weight_cut", m_sv1ip3d_weight_cut=0.);
55  declareProperty("MV_60_cut", m_mv_60_weight_cut=0.934906);
56  declareProperty("MV_70_cut", m_mv_70_weight_cut=0.8244273);
57  declareProperty("MV_77_cut", m_mv_77_weight_cut=0.645925);
58  declareProperty("MV_85_cut", m_mv_85_weight_cut=0.1758475);
59  declareProperty("MV_algorithmName", m_mv_algorithmName="MV2c10"); // added by SARA
60 
61  declareProperty("UseTrackSelector", m_use_trackselector = true);
62  declareProperty("UseTrigDecisionTool", m_use_trigdectool = true);
63  declareProperty("doLumiBlock", m_doLumiBlock=false);
64  declareProperty("doStatus", m_doStatus = false);
65 
66  declareProperty( "ElectronPtCut", m_ElectronPtCut = 25.0 ); // added by SARA - in GeV
67  declareProperty( "MuonPtCut", m_MuonPtCut = 25.0 ); // added by SARA - in GeV
68  declareProperty( "ElectronEtaCut", m_ElectronEtaCut = 2.47 ); // added by SARA
69  declareProperty( "MuonEtaCut", m_MuonEtaCut = 2.4 ); // added by SARA
70  declareProperty( "ElectronEtaCrackLowCut", m_ElectronEtaCrackLowCut = 1.37 ); // added by SARA
71  declareProperty( "ElectronEtaCrackHighCut", m_ElectronEtaCrackHighCut = 1.52 ); // added by SARA
72 
73  declareProperty( "ElectronTopoEtCone20Cut", m_ElectronTopoEtCone20Cut = 0.06 ); // added by SARA -0.06 corresponds to the FixedTightCut working point
74  declareProperty( "MuonTopoEtCone20Cut", m_MuonTopoEtCone20Cut = 0.06 ); // added by SARA -0.06 corresponds to the FixedTightCut working point
75  declareProperty( "ElectronPtVarCone20Cut", m_ElectronPtVarCone20Cut = 0.06 ); // added by SARA -0.06 corresponds to the FixedTightCut working point
76  declareProperty( "MuonPtVarCone20Cut", m_MuonPtVarCone20Cut = 0.06 ); // added by SARA -0.06 corresponds to the FixedTightCut working point
77  declareProperty( "MuonPtVarCone30Cut", m_MuonPtVarCone30Cut = 0.06 );// corresponds to the FixedTightCut working point
78 
79  declareProperty( "ElectronTrigger_2016", m_ElectronTrigger_2016 = "HLT_e26_lhtight_nod0_ivarloose" ); // added by SARA
80  declareProperty( "MuonTrigger_2016", m_MuonTrigger_2016 = "HLT_mu26_ivarmedium" ); // added by SARA
81  declareProperty( "JetTrigger_2016", m_JetTrigger_2016 = "HLT_j15" ); // added by SARA
82  declareProperty( "ElectronTrigger_2017", m_ElectronTrigger_2017 = "HLT_e28_lhtight_nod0_ivarloose" ); // added by SARA
83  declareProperty( "MuonTrigger_2017", m_MuonTrigger_2017 = "HLT_mu26_ivarmedium" ); // added by SARA
84  declareProperty( "JetTrigger_2017", m_JetTrigger_2017 = "HLT_j15" ); // added by SARA
85  declareProperty( "ElectronTrigger_201X", m_ElectronTrigger_201X = "HLT_e[2-9][0-9]_.*" ); // e20-e99 triggers
86  declareProperty( "MuonTrigger_201X", m_MuonTrigger_201X = "HLT_mu.*" ); // all mu triggers (including mu4 for Special Runs)
87 
88  m_isNewLumiBlock = false;
89 }
90 
91 //** --------------------------------------------------------------------------------------------------------------- **//
92 
93 
94 JetTagMonitoring::~JetTagMonitoring() {}
95 
96 
97 //** --------------------------------------------------------------------------------------------------------------- **//
98 
99 
100 void JetTagMonitoring::registerHist(MonGroup& theGroup, TH1* h1) {
101 
102  // msg(MSG::VERBOSE) << "in JetTagMonitoring::registerHist " << h1->GetName() << endmsg;
103  ATH_MSG_VERBOSE("in JetTagMonitoring::registerHist " << h1->GetName());
104 
105  StatusCode sc = theGroup.regHist(h1);
106  if (! sc.isSuccess())
107  ATH_MSG_WARNING("Could not register histogram ");
108 }
109 
110 //** --------------------------------------------------------------------------------------------------------------- **//
111 
112 
113 void JetTagMonitoring::registerHist(MonGroup& theGroup, LWHist* h1) {
114 
115  ATH_MSG_VERBOSE("in JetTagMonitoring::registerHist " << h1->GetName());
116 
117  StatusCode sc = theGroup.regHist(h1);
118  if (!sc.isSuccess())
119  ATH_MSG_WARNING("Could not register histogram ");
120 }
121 
122 
123 //** --------------------------------------------------------------------------------------------------------------- **//
124 
125 
126 
127 
128 
129 //** --------------------------------------------------------------------------------------------------------------- **//
130 
131 
132 
133 
134 StatusCode JetTagMonitoring::initialize() {
135 
136  ATH_MSG_INFO("in JetTagMonitoring::initialize");
137 
138  StatusCode sc = ManagedMonitorToolBase::initialize();
139  if (! sc.isSuccess()) {
140  ATH_MSG_WARNING("Unable to initialize ManagedMonitorToolBase");
141  return sc;
142  }
143 
144  ATH_CHECK(m_jetName.initialize());
145  ATH_CHECK(m_jetBtagKey.initialize());
146  ATH_CHECK(m_trackParticleName.initialize());
147  ATH_CHECK(m_primaryVertexName.initialize());
148  ATH_CHECK(m_electronName.initialize());
149  ATH_CHECK(m_muonName.initialize());
150  ATH_CHECK(m_eventInfoKey.initialize());
151 
152  if ( m_use_trackselector ) {
153  if ( m_trackSelectorTool.retrieve().isFailure() ) {
154  ATH_MSG_WARNING("Failed to retrieve tool " << m_trackSelectorTool);
155  m_switch_off = true;
156  }
157  } else {
158  ATH_MSG_INFO("Analysis::TrackSelector not used");
159  }
160 
161  if (!m_use_trigdectool) {
162  m_jtmTrigDecTool.disable();
163  }
164 
165  if ( m_switch_off )
166  ATH_MSG_WARNING("Switching off JetTagMonitoring::fillHistograms()");
167 
168  m_lumiBlockNum = 0;
169 
170  return StatusCode::SUCCESS;
171 }
172 
173 
174 //** --------------------------------------------------------------------------------------------------------------- **//
175 
176 
177 StatusCode JetTagMonitoring::bookHistograms() {
178 
179  ATH_MSG_DEBUG("bookHistograms()");
180 
181  m_isNewLumiBlock = newLumiBlockFlag();
182  if ( !newRunFlag() ) {
183  // Only book run-length histogram
184  return StatusCode::SUCCESS;
185  }
186 
187 
188  if ( (m_environment != AthenaMonManager::tier0) &&
189  (m_environment != AthenaMonManager::tier0ESD) &&
190  (m_environment != AthenaMonManager::online) ) {
191  // Only produce histograms from ESD, or from RAW if ESD-only monitoring is not enabled
192  ATH_MSG_INFO("Monitoring environment is \'" << m_environment << "\', not booking histograms");
193  // return StatusCode::SUCCESS;
194  }
195 
196  if ( m_dataType == AthenaMonManager::cosmics ) {
197  ATH_MSG_INFO("Cosmic-ray data, not booking histograms");
198  return StatusCode::SUCCESS;
199  }
200 
201  ATH_MSG_INFO("Monitoring environment is \'" << m_environment << "\', data type is \'" << m_dataType << "\', booking histograms now.");
202 
203 
204  m_monGr_shift = new MonGroup( this, "JetTagging", run );
205  m_monGr_LowStat = new MonGroup( this, "JetTagging", lowStat );
206 
208  // General histograms //
210 
211  registerHist(*m_monGr_shift, m_jet_n = TH1F_LW::create("jet_n","Number of Jets; Number of jets",50,0.,50.));
212  registerHist(*m_monGr_shift, m_jet_et = TH1F_LW::create("jet_et","Jet pT; pT [GeV]",100,0.,500.)); // this is actually filled with pT although called et...
213  registerHist(*m_monGr_shift, m_jet_eta = TH1F_LW::create("jet_eta","Jet #eta; #eta",100,-5.,5.));
214  registerHist(*m_monGr_shift, m_jet_phi = TH1F_LW::create("jet_phi","Jet #phi; #phi",100,-3.15,3.15));
215 
216  registerHist(*m_monGr_shift, m_global_nPrimVtx = TH1F_LW::create("global_nPrimVtx","Number of Primary Vertices; Number of PVs",30,0.,30.));
217  registerHist(*m_monGr_shift, m_global_xPrimVtx = TH1F_LW::create("global_xPrimVtx","Primary Vertex x Position; PV x [mm]",100,-5.0,5.0));
218  registerHist(*m_monGr_shift, m_global_yPrimVtx = TH1F_LW::create("global_yPrimVtx","Primary Vertex y Position; PV y [mm]",100,-5.0,5.0));
219  registerHist(*m_monGr_shift, m_global_zPrimVtx = TH1F_LW::create("global_zPrimVtx","Primary Vetex z Position; PV z [mm]",100,-250.,250.));
220  registerHist(*m_monGr_shift, m_priVtx_trks = TH1F_LW::create("priVtx_trks","Number of Tracks in PV; Number of tracks",150,-0.5,149.5));
221 
222  registerHist(*m_monGr_shift, m_trackParticle_n = TH1F_LW::create("NTrackParticle","Number of TrackParticles; Number of tracks",100,0.,1000.));
223  registerHist(*m_monGr_shift, m_global_BLayerHits = TH1F_LW::create("global_BLayerHits","Number of IBL Hits on TrackParticle; Number of IBL hits",5,0.,5.)); // updated by SARA // IBL hits in Run-2, old b-layer in Run-1
224  registerHist(*m_monGr_shift, m_global_PixelHits = TH1F_LW::create("global_PixelHits","Number of PIX Hits on TrackParticle; Number of PIX hits",10,0.,10.));
225  registerHist(*m_monGr_shift, m_global_SCTHits = TH1F_LW::create("global_SCTHits","Number of SCT Hits on TrackParticle; Number of SCT hits",15,0.,15.));
226  registerHist(*m_monGr_shift, m_global_SiHits = TH1F_LW::create("global_SiHits","Number of PIX+SCT Hits on TrackParticle; Number of PIX+SCT hits",25,0.,25.));
227  registerHist(*m_monGr_shift, m_global_TRTHits = TH1F_LW::create("global_TRTHits","Number of TRT Hits on TrackParticle; Number of TRT hits",100,0.,100.));
228 
229  registerHist(*m_monGr_shift, m_jet_tracks_n = TH1F_LW::create("jet_tracks_n","Number of Tracks per Jet; Number of tracks",50,0.,50.));
230  registerHist(*m_monGr_shift, m_jet_tracks_pt = TH1F_LW::create("jet_tracks_pt","pT of Tracks in Jets; pT [GeV]",100,0.,100.));
231  registerHist(*m_monGr_shift, m_jet_tracks_eta = TH1F_LW::create("jet_tracks_eta","#eta of Tracks in Jets; #eta",100,-2.5,2.5));
232  registerHist(*m_monGr_shift, m_jet_tracks_phi = TH1F_LW::create("jet_tracks_phi","#phi of Tracks in Jets; #phi",100,-TMath::Pi(),TMath::Pi()));
233  registerHist(*m_monGr_shift, m_jet_tracks_d0 = TH1F_LW::create("jet_tracks_d0","d0 of Tracks in Jets; d0 [mm]",100,-5.,5.));
234  registerHist(*m_monGr_shift, m_jet_tracks_z0 = TH1F_LW::create("jet_tracks_z0","z0 of Tracks in Jets; z0 [mm]",100,-300.,300.));
235  registerHist(*m_monGr_shift, m_jet_tracks_BLayerHits = TH1F_LW::create("jet_tracks_hits_BLayer","Number of IBL Hits on Tracks in Jets; Number of IBL hits",5,0.,5.)); // updatedby SARA // IBL hits in Run-2, old b-layer in Run-1
236  registerHist(*m_monGr_shift, m_jet_tracks_PixelHits = TH1F_LW::create("jet_tracks_hits_Pixel","Number of PIX Hits on Tracks in Jets; Number of PIX hits",10,0.,10.));
237  registerHist(*m_monGr_shift, m_jet_tracks_SCTHits = TH1F_LW::create("jet_tracks_hits_SCT","Number of SCT Hits on Tracks in Jets; Number of SCT hits",15,0.,15.));
238 
240  // Trigger histograms //
242 
243  //registerHist(*m_monGr_shift, m_trigPassed = TH1F_LW::create("trigPassed","Number of events passed trigger chains",40,-0.5,39.5));
244  registerHist(*m_monGr_shift, m_trigPassed = TH1F_LW::create("trigPassed","Number of events passed trigger chains",10,-0.5,9.5));
245 
246  m_trigPassed->GetXaxis()->SetBinLabel(1,"All") ;
247 
248  // 2016 menu
249  m_trigPassed->GetXaxis()->SetBinLabel(2,m_ElectronTrigger_2016.c_str());
250  m_trigPassed->GetXaxis()->SetBinLabel(3,m_MuonTrigger_2016.c_str());
251  m_trigPassed->GetXaxis()->SetBinLabel(4,(m_ElectronTrigger_2016+"_OR_"+m_MuonTrigger_2016).c_str());
252  m_trigPassed->GetXaxis()->SetBinLabel(5,m_JetTrigger_2016.c_str());
253 
254  // 2017 menu
255  m_trigPassed->GetXaxis()->SetBinLabel(6,m_ElectronTrigger_2017.c_str());
256  m_trigPassed->GetXaxis()->SetBinLabel(7,m_MuonTrigger_2017.c_str());
257  m_trigPassed->GetXaxis()->SetBinLabel(8,(m_ElectronTrigger_2017+"_OR_"+m_MuonTrigger_2017).c_str());
258  m_trigPassed->GetXaxis()->SetBinLabel(9,m_JetTrigger_2017.c_str());
259 
261  // Cutflow hitograms //
263 
264  registerHist(*m_monGr_shift, m_cutflow = TH1F_LW::create("DQ_Cutflow","Number of events passing cuts",10,-0.5,9.5));
265 
266  m_cutflow->GetXaxis()->SetBinLabel(1,"All");
267  m_cutflow->GetXaxis()->SetBinLabel(2,"Good LAr");
268  m_cutflow->GetXaxis()->SetBinLabel(3,"PV Present");
269  m_cutflow->GetXaxis()->SetBinLabel(4,"PV Ntrk");
270  m_cutflow->GetXaxis()->SetBinLabel(5,"Trigger");
271 
272  registerHist(*m_monGr_shift, m_cutflow_jet = TH1F_LW::create("Jet_Cutflow","Number of jets passing cuts",10,-0.5,9.5));
273 
274  m_cutflow_jet->GetXaxis()->SetBinLabel(1,"All");
275  m_cutflow_jet->GetXaxis()->SetBinLabel(2,"Quality Cuts");
276  m_cutflow_jet->GetXaxis()->SetBinLabel(3,"Kinematic Cuts");
277  m_cutflow_jet->GetXaxis()->SetBinLabel(4,"Taggable");
278  m_cutflow_jet->GetXaxis()->SetBinLabel(5,"Taggable Good");
279  m_cutflow_jet->GetXaxis()->SetBinLabel(6,"Taggable Suspect");
280 
282  // Pileup histograms //
284 
285  registerHist(*m_monGr_shift, m_n_mu = TH1F_LW::create("n_mu","Number of pile up interactions; <#mu>",100,-0.5,99.5));
286 
287  registerHist(*m_monGr_shift, m_tag_mv_w_mu0_30 = TH1F_LW::create("tag_MV_w_mu0_30" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, mu = [0,30]); "+m_mv_algorithmName+" tag weight").c_str(),100,-1.,1.));
288  registerHist(*m_monGr_shift, m_tag_mv_w_mu30_50 = TH1F_LW::create("tag_MV_w_mu30_50" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, mu = [30,50]); "+m_mv_algorithmName+" tag weight").c_str(),100,-1.,1.));
289  registerHist(*m_monGr_shift, m_tag_mv_w_mu50_70 = TH1F_LW::create("tag_MV_w_mu50_70" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, mu = [50,70]); "+m_mv_algorithmName+" tag weight").c_str(),100,-1.,1.));
290 
292  // Taggability histograms //
294 
295  registerHist(*m_monGr_shift, m_track_selector_eff = TH2F_LW::create("track_selector_eff", "Fraction of Taggable Jets;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
296  registerHist(*m_monGr_shift, m_track_selector_all = TH2F_LW::create("track_selector_all", "Number of Jets;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi())); // changed by SARA
297  registerHist(*m_monGr_shift, m_track_selector_suspect = TH2F_LW::create("track_selector_suspect", "Number of Taggable Suspect Jets;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
298 
299 
301  // Top histograms //
303 
304  registerHist(*m_monGr_shift, m_n_iso_el = TH1F_LW::create("n_iso_el","Number of Isolated Electrons; Number of electrons",10,-0.5,9.5)); // added by SARA (just for testing)
305  registerHist(*m_monGr_shift, m_n_iso_mu = TH1F_LW::create("n_iso_mu","Number of Isolated Muons; Number of muons",10,-0.5,9.5)); // added by SARA (just for testing)
306 
307  registerHist(*m_monGr_shift, m_jet_top = TH1F_LW::create("jet_top","Number of Jets in Top Events; Number of jets",1,-0.5,0.5)); // added by SARA
308  registerHist(*m_monGr_shift, m_jet_pt_top = TH1F_LW::create("jet_pt_top","pT of Jets in Top Events, pT [GeV]; pT",10,0.,200.)); // added by SARA
309  registerHist(*m_monGr_shift, m_jet_mv_w_top = TH1F_LW::create("jet_mv_top",(m_mv_algorithmName+" Tag Weight of Jets in Top Events; "+m_mv_algorithmName+" tag weight; "+m_mv_algorithmName+" tag weight").c_str(),100,-1.,1.)); // added by SARA
310 
311  registerHist(*m_monGr_shift, m_jet_top_tagged = TH1F_LW::create("jet_top_tagged","Number of b-tagged Jets in Top Events",1,-0.5,0.5)); // added by SARA
312  registerHist(*m_monGr_shift, m_jet_pt_top_tagged = TH1F_LW::create("jet_pt_top_tagged","pT of b-tagged Jets in Top Events; pT [GeV]",10,0.,200.)); // added by SARA
313 
314  registerHist(*m_monGr_shift, m_jet_top_eff = TH1F_LW::create("jet_top_eff","Fraction of b-tagged Jets in Top Events",1,-0.5,0.5)); // added by SARA
315  registerHist(*m_monGr_shift, m_jet_pt_top_eff = TH1F_LW::create("jet_pt_top_eff","Fraction of b-tagged Jets in Top Events vs pT; pT [GeV]",10,0.,200.)); // added by SARA
316 
318  // 2D jet hisograms //
320 
321  registerHist(*m_monGr_shift, m_jet_2D_all = TH2F_LW::create("jet_2D_all", "Number of Jets (No Cuts);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
322  registerHist(*m_monGr_shift, m_jet_2D_good = TH2F_LW::create("jet_2D_good", "Number of Jets (Quality Cuts);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
323  registerHist(*m_monGr_shift, m_jet_2D_jvt = TH2F_LW::create("jet_2D_jvt", "Number of Jets (JVT Cut);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
324  registerHist(*m_monGr_shift, m_jet_2D_kinematic = TH2F_LW::create("jet_2D_kinematic", "Number of Jets (Kinematic Cuts);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
325  registerHist(*m_monGr_shift, m_jet_2D_quality = TH2F_LW::create("jet_2D_quality", "Number of Jets (Taggable Good);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
326  registerHist(*m_monGr_shift, m_jet_2D_suspect = TH2F_LW::create("jet_2D_suspect", "Number of Jets (Taggable Suspect);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
327  registerHist(*m_monGr_shift, m_jet_2D_bad = TH2F_LW::create("jet_2D_bad", "Number of Jets (Non-Taggable);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
328 
330  // Tag weight histograms //
332 
333  // MV Tagger
334 
335  registerHist(*m_monGr_shift, m_tag_mv_w = TH1F_LW::create("tag_MV_w",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets); "+m_mv_algorithmName+" tag weight").c_str(),100,-1.,1.));
336 
337  registerHist(*m_monGr_shift, m_tag_mv_w_pT10_20 = TH1F_LW::create("tag_MV_w_pT10_20" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, pT = [10,20] GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
338  registerHist(*m_monGr_shift, m_tag_mv_w_pT20_50 = TH1F_LW::create("tag_MV_w_pT20_50" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, pT = [20,50] GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
339  registerHist(*m_monGr_shift, m_tag_mv_w_pT50_100 = TH1F_LW::create("tag_MV_w_pT50_100" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, pT = [50,100] GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
340  registerHist(*m_monGr_shift, m_tag_mv_w_pT100_200 = TH1F_LW::create("tag_MV_w_pT100_200",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, pT = [100,200] GeV); "+m_mv_algorithmName+" tag weight").c_str(),100,-1.,1.));
341  registerHist(*m_monGr_shift, m_tag_mv_w_pT200 = TH1F_LW::create("tag_MV_w_pT200" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, pT > 200 GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
342 
343  registerHist(*m_monGr_shift, m_tag_mv_w_eta0_05 = TH1F_LW::create("tag_MV_w_eta0_05" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, |#eta| = [0.0,0.5]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
344  registerHist(*m_monGr_shift, m_tag_mv_w_eta05_10 = TH1F_LW::create("tag_MV_w_eta05_10",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, |#eta| = [0.5,1.0]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
345  registerHist(*m_monGr_shift, m_tag_mv_w_eta10_15 = TH1F_LW::create("tag_MV_w_eta10_15",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, |#eta| = [1.0,1.5]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
346  registerHist(*m_monGr_shift, m_tag_mv_w_eta15_20 = TH1F_LW::create("tag_MV_w_eta15_20",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, |#eta| = [1.5,2.0]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
347  registerHist(*m_monGr_shift, m_tag_mv_w_eta20_25 = TH1F_LW::create("tag_MV_w_eta20_25",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, |#eta| = [2.0,2.5]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
348 
349  registerHist(*m_monGr_shift, m_tag_mv_w_phi0_07 = TH1F_LW::create("tag_MV_w_phi0_07" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, |#phi| = [0.0,0.7]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
350  registerHist(*m_monGr_shift, m_tag_mv_w_phi07_14 = TH1F_LW::create("tag_MV_w_phi07_14",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, |#phi| = [0.7,1.4]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
351  registerHist(*m_monGr_shift, m_tag_mv_w_phi14_21 = TH1F_LW::create("tag_MV_w_phi14_21",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, |#phi| = [1.4,2.1]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
352  registerHist(*m_monGr_shift, m_tag_mv_w_phi21_28 = TH1F_LW::create("tag_MV_w_phi21_28",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, |#phi| = [2.1,2.8]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
353  registerHist(*m_monGr_shift, m_tag_mv_w_phi28 = TH1F_LW::create("tag_MV_w_phi28",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, |#phi| > 2.8); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
354 
355  registerHist(*m_monGr_shift, m_mv_tag_60_2D = TH2F_LW::create("mv_tag_60_rate_2D", ("Number of Tagged Jets vs #eta and #phi ("+m_mv_algorithmName+" @ 60% WP);#eta;#phi").c_str(), 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
356  registerHist(*m_monGr_shift, m_mv_tag_70_2D = TH2F_LW::create("mv_tag_70_rate_2D", ("Number of Tagged Jets vs #eta and #phi ("+m_mv_algorithmName+" @ 70% WP);#eta;#phi").c_str(), 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
357  registerHist(*m_monGr_shift, m_mv_tag_77_2D = TH2F_LW::create("mv_tag_77_rate_2D", ("Number of Tagged Jets vs #eta and #phi ("+m_mv_algorithmName+" @ 77% WP);#eta;#phi").c_str(), 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
358 
359  registerHist(*m_monGr_shift, m_tag_mv_w_phi_sum85OP = TH1F_LW::create("tag_MV_w_phi_sum85OP",("Number of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 85% WP, Taggable Good Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
360  registerHist(*m_monGr_shift, m_tag_mv_w_phi_sum77OP = TH1F_LW::create("tag_MV_w_phi_sum77OP",("Number of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 77% WP, Taggable Good Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
361  registerHist(*m_monGr_shift, m_tag_mv_w_phi_sum70OP = TH1F_LW::create("tag_MV_w_phi_sum70OP",("Number of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 70% WP, Taggable Good Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
362  registerHist(*m_monGr_shift, m_tag_mv_w_phi_sum60OP = TH1F_LW::create("tag_MV_w_phi_sum60OP",("Number of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 60% WP, Taggable Good Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
363  registerHist(*m_monGr_shift, m_tag_mv_w_phi_sumAll = TH1F_LW::create("tag_MV_w_phi_sumAll" ,"Number of Jets vs #phi (Taggable Good Jets); #phi" ,14,-TMath::Pi(),TMath::Pi()));
364  registerHist(*m_monGr_shift, m_tag_mv_w_phi_frac85OP = TH1F_LW::create("tag_MV_w_phi_frac85OP",("Fraction of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 85% WP, Taggable Good Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
365  registerHist(*m_monGr_shift, m_tag_mv_w_phi_frac77OP = TH1F_LW::create("tag_MV_w_phi_frac77OP",("Fraction of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 77% WP, Taggable Good Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
366  registerHist(*m_monGr_shift, m_tag_mv_w_phi_frac70OP = TH1F_LW::create("tag_MV_w_phi_frac70OP",("Fraction of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 70% WP, Taggable Good Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
367  registerHist(*m_monGr_shift, m_tag_mv_w_phi_frac60OP = TH1F_LW::create("tag_MV_w_phi_frac60OP",("Fraction of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 60% WP, Taggable Good Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
368 
369  registerHist(*m_monGr_shift, m_tag_mv_w_eta_sum85OP = TH1F_LW::create("tag_MV_w_eta_sum85OP",("Number of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 85% WP, Taggable Good Jets); #eta").c_str() ,20,-2.5,2.5));
370  registerHist(*m_monGr_shift, m_tag_mv_w_eta_sum77OP = TH1F_LW::create("tag_MV_w_eta_sum77OP",("Number of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 77% WP, Taggable Good Jets); #eta").c_str() ,20,-2.5,2.5));
371  registerHist(*m_monGr_shift, m_tag_mv_w_eta_sum70OP = TH1F_LW::create("tag_MV_w_eta_sum70OP",("Number of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 70% WP, Taggable Good Jets); #eta").c_str() ,20,-2.5,2.5));
372  registerHist(*m_monGr_shift, m_tag_mv_w_eta_sum60OP = TH1F_LW::create("tag_MV_w_eta_sum60OP",("Number of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 60% WP, Taggable Good Jets); #eta").c_str() ,20,-2.5,2.5));
373  registerHist(*m_monGr_shift, m_tag_mv_w_eta_sumAll = TH1F_LW::create("tag_MV_w_eta_sumAll" ,"Number of Jets vs #eta (Taggable Good Jets); #eta" ,20,-2.5,2.5));
374  registerHist(*m_monGr_shift, m_tag_mv_w_eta_frac85OP = TH1F_LW::create("tag_MV_w_eta_frac85OP",("Fraction of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 85% WP, Taggable Good Jets); #eta").c_str() ,20,-2.5,2.5));
375  registerHist(*m_monGr_shift, m_tag_mv_w_eta_frac77OP = TH1F_LW::create("tag_MV_w_eta_frac77OP",("Fraction of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 77% WP, Taggable Good Jets); #eta").c_str() ,20,-2.5,2.5));
376  registerHist(*m_monGr_shift, m_tag_mv_w_eta_frac70OP = TH1F_LW::create("tag_MV_w_eta_frac70OP",("Fraction of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 70% WP, Taggable Good Jets); #eta").c_str() ,20,-2.5,2.5));
377  registerHist(*m_monGr_shift, m_tag_mv_w_eta_frac60OP = TH1F_LW::create("tag_MV_w_eta_frac60OP",("Fraction of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 60% WP, Taggable Good Jets); #eta").c_str() ,20,-2.5,2.5));
378 
379  registerHist(*m_monGr_shift, m_tag_mv_w_sj = TH1F_LW::create("tag_MV_w_sj",(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets); "+m_mv_algorithmName+" tag weight").c_str(),100,-1.,1.));
380 
381  registerHist(*m_monGr_shift, m_tag_mv_w_sj_pT10_20 = TH1F_LW::create("tag_MV_w_sj_pT10_20" ,(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, pT = [10,20] GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
382  registerHist(*m_monGr_shift, m_tag_mv_w_sj_pT20_50 = TH1F_LW::create("tag_MV_w_sj_pT20_50" ,(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, pT = [20,50] GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
383  registerHist(*m_monGr_shift, m_tag_mv_w_sj_pT50_100 = TH1F_LW::create("tag_MV_w_sj_pT50_100" ,(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, pT = [50,100] GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
384  registerHist(*m_monGr_shift, m_tag_mv_w_sj_pT100_200 = TH1F_LW::create("tag_MV_w_sj_pT100_200",(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, pT = [100,200] GeV); "+m_mv_algorithmName+" tag weight").c_str(),100,-1.,1.));
385  registerHist(*m_monGr_shift, m_tag_mv_w_sj_pT200 = TH1F_LW::create("tag_MV_w_sj_pT200" ,(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, pT > 200 GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
386 
387  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta0_05 = TH1F_LW::create("tag_MV_w_sj_eta0_05" ,(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, |#eta| = [0.0,0.5]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
388  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta05_10 = TH1F_LW::create("tag_MV_w_sj_eta05_10",(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, |#eta| = [0.5,1.0]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
389  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta10_15 = TH1F_LW::create("tag_MV_w_sj_eta10_15",(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, |#eta| = [1.0,1.5]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
390  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta15_20 = TH1F_LW::create("tag_MV_w_sj_eta15_20",(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, |#eta| = [1.5,2.0]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
391  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta20_25 = TH1F_LW::create("tag_MV_w_sj_eta20_25",(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, |#eta| = [2.0,2.5]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
392 
393  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi0_07 = TH1F_LW::create("tag_MV_w_sj_phi0_07" ,(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, |#phi| = [0.0,0.7]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
394  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi07_14 = TH1F_LW::create("tag_MV_w_sj_phi07_14",(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, |#phi| = [0.7,1.4]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
395  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi14_21 = TH1F_LW::create("tag_MV_w_sj_phi14_21",(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, |#phi| = [1.4,2.1]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
396  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi21_28 = TH1F_LW::create("tag_MV_w_sj_phi21_28",(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, |#phi| = [2.1,2.8]); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
397  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi28 = TH1F_LW::create("tag_MV_w_sj_phi28",(m_mv_algorithmName+" Tag Weight (Taggable Suspect Jets, |#phi| > 2.8); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
398 
399  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi_sum85OP = TH1F_LW::create("tag_MV_w_sj_phi_sum85OP",("Number of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 85% WP, Taggable Suspect Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
400  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi_sum77OP = TH1F_LW::create("tag_MV_w_sj_phi_sum77OP",("Number of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 77% WP, Taggable Suspect Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
401  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi_sum70OP = TH1F_LW::create("tag_MV_w_sj_phi_sum70OP",("Number of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 70% WP, Taggable Suspect Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
402  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi_sum60OP = TH1F_LW::create("tag_MV_w_sj_phi_sum60OP",("Number of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 60% WP, Taggable Suspect Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
403  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi_sumAll = TH1F_LW::create("tag_MV_w_sj_phi_sumAll" ,"Number of Jets vs #phi (Taggable Suspect Jets); #phi" ,14,-TMath::Pi(),TMath::Pi()));
404  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi_frac85OP = TH1F_LW::create("tag_MV_w_sj_phi_frac85OP",("Fraction of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 85% WP, Taggable Suspect Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
405  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi_frac77OP = TH1F_LW::create("tag_MV_w_sj_phi_frac77OP",("Fraction of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 77% WP, Taggable Suspect Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
406  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi_frac70OP = TH1F_LW::create("tag_MV_w_sj_phi_frac70OP",("Fraction of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 70% WP, Taggable Suspect Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
407  registerHist(*m_monGr_shift, m_tag_mv_w_sj_phi_frac60OP = TH1F_LW::create("tag_MV_w_sj_phi_frac60OP",("Fraction of Tagged Jets vs #phi ("+m_mv_algorithmName+" @ 60% WP, Taggable Suspect Jets); #phi").c_str() ,14,-TMath::Pi(),TMath::Pi()));
408 
409  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta_sum85OP = TH1F_LW::create("tag_MV_w_sj_eta_sum85OP",("Number of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 85% WP, Taggable Suspect Jets); #eta").c_str() ,20,-2.5,2.5));
410  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta_sum77OP = TH1F_LW::create("tag_MV_w_sj_eta_sum77OP",("Number of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 77% WP, Taggable Suspect Jets); #eta").c_str() ,20,-2.5,2.5));
411  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta_sum70OP = TH1F_LW::create("tag_MV_w_sj_eta_sum70OP",("Number of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 70% WP, Taggable Suspect Jets); #eta").c_str() ,20,-2.5,2.5));
412  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta_sum60OP = TH1F_LW::create("tag_MV_w_sj_eta_sum60OP",("Number of Tagged Jets vs #ets ("+m_mv_algorithmName+" @ 60% WP, Taggable Suspect Jets); #eta").c_str() ,20,-2.5,2.5));
413  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta_sumAll = TH1F_LW::create("tag_MV_w_sj_eta_sumAll" ,"Number of Jets vs #eta (Taggable Suspect Jets); #eta" ,20,-2.5,2.5));
414  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta_frac85OP = TH1F_LW::create("tag_MV_w_sj_eta_frac85OP",("Fraction of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 85% WP, Taggable Suspect Jets); #eta").c_str() ,20,-2.5,2.5));
415  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta_frac77OP = TH1F_LW::create("tag_MV_w_sj_eta_frac77OP",("Fraction of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 77% WP, Taggable Suspect Jets); #eta").c_str() ,20,-2.5,2.5));
416  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta_frac70OP = TH1F_LW::create("tag_MV_w_sj_eta_frac70OP",("Fraction of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 70% WP, Taggable Suspect Jets); #eta").c_str() ,20,-2.5,2.5));
417  registerHist(*m_monGr_shift, m_tag_mv_w_sj_eta_frac60OP = TH1F_LW::create("tag_MV_w_sj_eta_frac60OP",("Fraction of Tagged Jets vs #eta ("+m_mv_algorithmName+" @ 60% WP, Taggable Suspect Jets); #eta").c_str() ,20,-2.5,2.5));
418 
419  // SV1+IP3D, IP2D and IP3D Taggers
420 
421  registerHist(*m_monGr_shift, m_tag_sv1ip3d_w = TH1F_LW::create("tag_SV1IP3D_w","SV1+IP3D Tag Weight (Taggable Good Jets); SV1+IP3D tag weight",100,-10.,10.));
422  registerHist(*m_monGr_shift, m_sv1ip3d_tag_pos_rate_2D = TH2F_LW::create("sv1ip3d_tag_pos_rate_2D", "SV1+IP3D Positive Tag Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
423  registerHist(*m_monGr_shift, m_sv1ip3d_tag_neg_rate_2D = TH2F_LW::create("sv1ip3d_tag_neg_rate_2D", "SV1+IP3D Negative Tag Rate;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
424 
425  registerHist(*m_monGr_shift, m_tag_sv1ip3d_w_sj = TH1F_LW::create("tag_SV1IP3D_w_sj","SV1+IP3D Tag Weight (Taggable Suspect Jets); SV1+IP3D tag weight",100,-10.,10.));
426 
427  registerHist(*m_monGr_shift, m_tag_ip2d_n = TH1F_LW::create("tag_IP2D_n","Number of IP2D Tracks (Taggable Good Jets); Number of tracks",20,0.,20.));
428  registerHist(*m_monGr_shift, m_tag_ip2d_b = TH1F_LW::create("tag_IP2D_b","IP2D Pb (Taggable Good Jets); IP2D Pb",100,0.,1.));
429  registerHist(*m_monGr_shift, m_tag_ip2d_u = TH1F_LW::create("tag_IP2D_u","IP2D Pu (Taggable Good Jets); IP2D Pu",100,0.,1.));
430  registerHist(*m_monGr_shift, m_tag_ip2d_c = TH1F_LW::create("tag_IP2D_c","IP2D Pc (Taggable Good Jets); IP2D Pc",100,0.,1.));
431  registerHist(*m_monGr_shift, m_tag_ip2d_llr = TH1F_LW::create("tag_IP2D_llr","IP2D llr (Taggable Good Jets); IP2D llr",160,-40.,40.));
432 
433  registerHist(*m_monGr_shift, m_tag_ip2d_n_sj = TH1F_LW::create("tag_IP2D_n_sj","Number of IP2D Tracks (Taggable Suspect Jets); Number of tracks",20,0.,20.));
434  registerHist(*m_monGr_shift, m_tag_ip2d_b_sj = TH1F_LW::create("tag_IP2D_b_sj","IP2D Pb (Taggable Suspect Jets); IP2D Pb",100,0.,1.));
435  registerHist(*m_monGr_shift, m_tag_ip2d_u_sj = TH1F_LW::create("tag_IP2D_u_sj","IP2D Pu (Taggable Suspect Jets); IP2D Pu",100,0.,1.));
436  registerHist(*m_monGr_shift, m_tag_ip2d_c_sj = TH1F_LW::create("tag_IP2D_c_sj","IP2D Pc (Taggable Suspect Jets); IP2D Pc",100,0.,1.));
437  registerHist(*m_monGr_shift, m_tag_ip2d_llr_sj = TH1F_LW::create("tag_IP2D_llr_sj","IP2D llr (Taggable Suspect Jets); IP2D llr",160,-40.,40.));
438 
439  registerHist(*m_monGr_shift, m_tag_ip3d_n = TH1F_LW::create("tag_IP3D_n","Number of IP3D Tracks (Taggable Good Jets); Number of tracks",20,0.,20.));
440  registerHist(*m_monGr_shift, m_tag_ip3d_b = TH1F_LW::create("tag_IP3D_b","IP3D Pb (Taggable Good Jets); IP3D Pb",100,0.,1.));
441  registerHist(*m_monGr_shift, m_tag_ip3d_u = TH1F_LW::create("tag_IP3D_u","IP3D Pu (Taggable Good Jets); IP3D Pu",100,0.,1.));
442  registerHist(*m_monGr_shift, m_tag_ip3d_c = TH1F_LW::create("tag_IP3D_c","IP3D Pc (Taggable Good Jets); IP3D Pc",100,0.,1.));
443  registerHist(*m_monGr_shift, m_tag_ip3d_llr = TH1F_LW::create("tag_IP3D_llr","IP3D llr (Taggable Good Jets); IP3D llr",160,-40.,40.));
444 
445  registerHist(*m_monGr_shift, m_tag_ip3d_n_sj = TH1F_LW::create("tag_IP3D_n_sj","Number of IP3D Tracks (Taggable Suspect Jets); Number of tracks",20,0.,20.));
446  registerHist(*m_monGr_shift, m_tag_ip3d_b_sj = TH1F_LW::create("tag_IP3D_b_sj","IP3D Pb (Taggable Suspect Jets); IP3D Pb",100,0.,1.));
447  registerHist(*m_monGr_shift, m_tag_ip3d_u_sj = TH1F_LW::create("tag_IP3D_u_sj","IP3D Pu (Taggable Suspect Jets); IP3D Pu",100,0.,1.));
448  registerHist(*m_monGr_shift, m_tag_ip3d_c_sj = TH1F_LW::create("tag_IP3D_c_sj","IP3D Pc (Taggable Suspect Jets); IP3D Pc",100,0.,1.));
449  registerHist(*m_monGr_shift, m_tag_ip3d_llr_sj = TH1F_LW::create("tag_IP3D_llr_sj","IP3D llr (Taggable Suspect Jets); IP3D llr",160,-40.,40.));
450 
451  // SV0 and SV1 Taggers
452 
453  registerHist(*m_monGr_shift, m_tag_sv0_sig3d = TH1F_LW::create("tag_SV0_sig3d","SV1 sig3d; SV1 sig3d",100, 0.,100.));
454 
455  registerHist(*m_monGr_shift, m_tag_sv1_b = TH1F_LW::create("tag_SV1_b","SV1 Pb (Taggable Good Jets); SV1 Pb",100,0.,1.));
456  registerHist(*m_monGr_shift, m_tag_sv1_u = TH1F_LW::create("tag_SV1_u","SV1 Pu (Taggable Good Jets); SV1 Pu",100,0.,1.));
457  registerHist(*m_monGr_shift, m_tag_sv1_c = TH1F_LW::create("tag_SV1_c","SV1 Pc (Taggable Good Jets); SV1 Pc",100,0.,1.));
458  registerHist(*m_monGr_shift, m_tag_sv1_llr = TH1F_LW::create("tag_SV1_llr","SV1 llr (Taggable Good Jets); SV1 llr",160,-40.,40.));
459 
460  registerHist(*m_monGr_shift, m_tag_sv1_b_sj = TH1F_LW::create("tag_SV1_b_sj","SV1 Pb (Taggable Suspect Jets); SV1 Pb",100,0.,1.));
461  registerHist(*m_monGr_shift, m_tag_sv1_u_sj = TH1F_LW::create("tag_SV1_u_sj","SV1 Pu (Taggable Suspect Jets); SV1 Pu",100,0.,1.));
462  registerHist(*m_monGr_shift, m_tag_sv1_c_sj = TH1F_LW::create("tag_SV1_c_sj","SV1 Pc (Taggable Suspect Jets); SV1 Pc",100,0.,1.));
463  registerHist(*m_monGr_shift, m_tag_sv1_llr_sj = TH1F_LW::create("tag_SV1_llr_sj","SV1 llr (Taggable Suspect Jets); SV1 llr",160,-40.,40.));
464 
465  // JetFitter Taggers
466 
467  registerHist(*m_monGr_shift, m_tag_jetfitter_llr = TH1F_LW::create("tag_JetFitter_llr","JetFitter llr (Taggable Good Jets); JetFitter llr",160,-40.,40.));
468  registerHist(*m_monGr_shift, m_tag_jfcnn_llr = TH1F_LW::create("tag_JFCNN_llr","JetFitterCOMBNN Tag Weight (Taggable Good Jets); JetFitterCOMBNN tag weight",160,-40.,40.));
469 
470  registerHist(*m_monGr_shift, m_tag_jetfitter_llr_sj = TH1F_LW::create("tag_JetFitter_llr_sj","JetFitter llr (Taggable Suspect Jets); JetFitter llr",160,-40.,40.));
471  registerHist(*m_monGr_shift, m_tag_jfcnn_llr_sj = TH1F_LW::create("tag_JFCNN_llr_sj","JetFitterCOMBNN Tag Weight (Taggable Suspect Jets); JetFitterCOMBNN tag weight",160,-40.,40.));
472 
474  // Track cut histograms //
476 
477  registerHist(*m_monGr_shift, m_tracks_all_2D = TH2F_LW::create("tracks_all_2D", "Number of Tracks (No Cuts); #eta; #phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
478  registerHist(*m_monGr_shift, m_tracks_pTMin_2D = TH2F_LW::create("tracks_pTMin_2D", "Number of Tracks Failing pTMin Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
479  registerHist(*m_monGr_shift, m_tracks_d0Max_2D = TH2F_LW::create("tracks_d0Max_2D", "Number of Tracks Failing d0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
480  registerHist(*m_monGr_shift, m_tracks_z0Max_2D = TH2F_LW::create("tracks_z0Max_2D", "Number of Tracks Failing z0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
481  registerHist(*m_monGr_shift, m_tracks_sigd0Max_2D = TH2F_LW::create("tracks_sigd0Max_2D", "Number of Tracks Failing sigd0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
482  registerHist(*m_monGr_shift, m_tracks_sigz0Max_2D = TH2F_LW::create("tracks_sigz0Max_2D", "Number of Tracks Failing sigz0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
483  registerHist(*m_monGr_shift, m_tracks_etaMax_2D = TH2F_LW::create("tracks_etaMax_2D", "Number of Tracks Failing etaMax Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
484  registerHist(*m_monGr_shift, m_tracks_nHitBLayer_2D = TH2F_LW::create("tracks_nHitBLayer_2D", "Number of Tracks Failing IBL Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi())); // IBL hits in Run-2, old b-layer in Run-1
485  registerHist(*m_monGr_shift, m_tracks_deadBLayer_2D = TH2F_LW::create("tracks_deadBLayer_2D", "Number of Tracks Failing Dead IBL Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi())); // IBL hits in Run-2, old b-layer in Run-1
486  registerHist(*m_monGr_shift, m_tracks_nHitPix_2D = TH2F_LW::create("tracks_nHitPix_2D", "Number of Tracks Failing PIX Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
487  registerHist(*m_monGr_shift, m_tracks_nHitSct_2D = TH2F_LW::create("tracks_nHitSct_2D", "Number of Tracks Failing SCT Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
488  registerHist(*m_monGr_shift, m_tracks_nHitSi_2D = TH2F_LW::create("tracks_nHitSi_2D", "Number of Tracks Failing Silicon Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
489  registerHist(*m_monGr_shift, m_tracks_nHitTrt_2D = TH2F_LW::create("tracks_nHitTrt_2D", "Number of Tracks Failing TRT Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
490  registerHist(*m_monGr_shift, m_tracks_nHitTrtHighE_2D = TH2F_LW::create("tracks_nHitTrtHighE_2D", "Number of Tracks Failing TRT High E Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
491  registerHist(*m_monGr_shift, m_tracks_fitChi2_2D = TH2F_LW::create("tracks_fitChi2_2D", "Number of Tracks Failing fitChi2 Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
492  registerHist(*m_monGr_shift, m_tracks_fitProb_2D = TH2F_LW::create("tracks_fitProb_2D", "Number of Tracks Failing fitProb Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
493  registerHist(*m_monGr_shift, m_tracks_fitChi2OnNdfMax_2D = TH2F_LW::create("tracks_fitChi2OnNdfMax_2D", "Number of Tracks Failing fitChi2OnNdfMax Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
494  registerHist(*m_monGr_shift, m_tracks_passedCuts_2D = TH2F_LW::create("tracks_passedCuts_2D", "Number of Tracks Passing All Cuts;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
495 
497  // LowStat histograms //
499 
500  if ( newRunFlag() || newLowStatIntervalFlag() ) {
501  registerHist(*m_monGr_LowStat, m_tracks_all_2D_LS = TH2F_LW::create("tracks_all_2D_LS", "Number of Tracks (No Cuts);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
502  registerHist(*m_monGr_LowStat, m_tracks_pTMin_2D_LS = TH2F_LW::create("tracks_pTMin_2D_LS", "Number of Tracks Failing pTMin Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
503  registerHist(*m_monGr_LowStat, m_tracks_d0Max_2D_LS = TH2F_LW::create("tracks_d0Max_2D_LS", "Number of Tracks Failing d0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
504  registerHist(*m_monGr_LowStat, m_tracks_z0Max_2D_LS = TH2F_LW::create("tracks_z0Max_2D_LS", "Number of Tracks Failing z0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
505  registerHist(*m_monGr_LowStat, m_tracks_sigd0Max_2D_LS = TH2F_LW::create("tracks_sigd0Max_2D_LS", "Number of Tracks Failing sigd0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
506  registerHist(*m_monGr_LowStat, m_tracks_sigz0Max_2D_LS = TH2F_LW::create("tracks_sigz0Max_2D_LS", "Number of Tracks Failing sigz0Max Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
507  registerHist(*m_monGr_LowStat, m_tracks_etaMax_2D_LS = TH2F_LW::create("tracks_etaMax_2D_LS", "Number of Tracks Failing etaMax Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
508  registerHist(*m_monGr_LowStat, m_tracks_nHitBLayer_2D_LS = TH2F_LW::create("tracks_nHitBLayer_2D_LS", "Number of Tracks Failing IBL Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi())); // IBL hits in Run-2, old b-layer in Run-1
509  registerHist(*m_monGr_LowStat, m_tracks_deadBLayer_2D_LS = TH2F_LW::create("tracks_deadBLayer_2D_LS", "Number of Tracks Failing Dead IBL Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi())); // IBL hits in Run-2, old b-layer in Run-1
510  registerHist(*m_monGr_LowStat, m_tracks_nHitPix_2D_LS = TH2F_LW::create("tracks_nHitPix_2D_LS", "Number of Tracks Failing PIX Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
511  registerHist(*m_monGr_LowStat, m_tracks_nHitSct_2D_LS = TH2F_LW::create("tracks_nHitSct_2D_LS", "Number of Tracks Failing SCT Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
512  registerHist(*m_monGr_LowStat, m_tracks_nHitSi_2D_LS = TH2F_LW::create("tracks_nHitSi_2D_LS", "Number of Tracks Failing Silicon Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
513  registerHist(*m_monGr_LowStat, m_tracks_nHitTrt_2D_LS = TH2F_LW::create("tracks_nHitTrt_2D_LS", "Number of Tracks Failing TRT Hits Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
514  registerHist(*m_monGr_LowStat, m_tracks_nHitTrtHighE_2D_LS = TH2F_LW::create("tracks_nHitTrtHighE_2D_LS", "Number of Tracks Failing TRT High E Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
515  registerHist(*m_monGr_LowStat, m_tracks_fitChi2_2D_LS = TH2F_LW::create("tracks_fitChi2_2D_LS", "Number of Tracks Failing fitChi2 Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
516  registerHist(*m_monGr_LowStat, m_tracks_fitProb_2D_LS = TH2F_LW::create("tracks_fitProb_2D_LS", "Numbr of Tracks Failing fitProb Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
517  registerHist(*m_monGr_LowStat, m_tracks_fitChi2OnNdfMax_2D_LS = TH2F_LW::create("tracks_fitChi2OnNdfMax_2D_LS", "Number of Tracks Failing fitChi2OnNdfMax Cut;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
518 
519  registerHist(*m_monGr_LowStat, m_jet_tracks_d0_LS = TH1F_LW::create("jet_tracks_d0_LS","d0 of Tracks in Jets; d0 [mm]",100,-5.,5.));
520  registerHist(*m_monGr_LowStat, m_jet_tracks_z0_LS = TH1F_LW::create("jet_tracks_z0_LS","z0 of Tracks in Jets; z0 [mm]",100,-300.,300.));
521 
522  // registerHist(*m_monGr_LowStat, m_mv_tag_77_2D_LS = TH2F_LW::create("mv_tag_77_2D_LS", (m_mv_algorithmName+" Tag 77%").c_str(), 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
523  registerHist(*m_monGr_LowStat, m_tag_mv_w_LS = TH1F_LW::create("tag_MV_w_LS",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets); "+m_mv_algorithmName+" tag weight").c_str(),100,-1.,1.));
524  registerHist(*m_monGr_LowStat, m_tag_mv_w_pT10_20_LS = TH1F_LW::create("tag_MV_w_pT10_20_LS" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, pT = [10,20] GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
525  registerHist(*m_monGr_LowStat, m_tag_mv_w_pT20_50_LS = TH1F_LW::create("tag_MV_w_pT20_50_LS" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, pT = [20,50] GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
526  registerHist(*m_monGr_LowStat, m_tag_mv_w_pT50_100_LS = TH1F_LW::create("tag_MV_w_pT50_100_LS" ,(m_mv_algorithmName+" Tag Weight Taggable Good Jets, pT = [50,100] GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
527  registerHist(*m_monGr_LowStat, m_tag_mv_w_pT100_200_LS = TH1F_LW::create("tag_MV_w_pT100_200_LS",(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, pT = [100,200] GeV); "+m_mv_algorithmName+" tag weight").c_str(),100,-1.,1.));
528  registerHist(*m_monGr_LowStat, m_tag_mv_w_pT200_LS = TH1F_LW::create("tag_MV_w_pT200_LS" ,(m_mv_algorithmName+" Tag Weight (Taggable Good Jets, pT > 200 GeV); "+m_mv_algorithmName+" tag weight").c_str() ,100,-1.,1.));
529 
530  registerHist(*m_monGr_LowStat, m_jet_2D_kinematic_LS = TH2F_LW::create("jet_2D_kinematic_LS", "Number of Jets (Kinematic Cuts);#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
531  registerHist(*m_monGr_LowStat, m_track_selector_eff_LS = TH2F_LW::create("track_selector_eff_LS", "Fraction of Taggable Jets;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
532  registerHist(*m_monGr_LowStat, m_track_selector_all_LS = TH2F_LW::create("track_selector_all_LS", "Number of Jets;#eta;#phi", 25, -2.5, 2.5, 25, -TMath::Pi(), TMath::Pi()));
533  }
534 
535  /*
536  Ended registering LowStat histograms
537  */
538 
539  m_histogramsCreated = true;
540 
541  return StatusCode::SUCCESS;
542 }
543 
544 
545 //** --------------------------------------------------------------------------------------------------------------- **//
546 
547 
548 StatusCode JetTagMonitoring::fillHistograms() {
549 
550  ATH_MSG_DEBUG("fillHistograms()");
551 
552  if (!m_histogramsCreated)
553  return StatusCode::SUCCESS;
554 
555  if (m_switch_off)
556  return StatusCode::SUCCESS;
557 
558  m_cutflow->Fill(0.);
559 
560  SG::ReadHandle<xAOD::EventInfo> thisEventInfo{m_eventInfoKey};
561  if (!thisEventInfo.isValid()) {
562  ATH_MSG_ERROR("Cannot retrieve EventInfo");
563  return StatusCode::FAILURE;
564  }
565 
566  m_lumiBlockNum = thisEventInfo->lumiBlock();
567 
568  ATH_MSG_DEBUG("Lumiblock ID: " << m_lumiBlockNum);
569 
570  m_runNumber = thisEventInfo->runNumber();
571 
572  // r21 MV2c10 Working Points (https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTaggingBenchmarksRelease21) for 2018 data
573  if(m_runNumber > 343000)
574  {
575  m_mv_60_weight_cut=0.94;
576  m_mv_70_weight_cut=0.83;
577  m_mv_77_weight_cut=0.64;
578  m_mv_85_weight_cut=0.11;
579  }
580 
582  //* Event cleaning *//
584 
585  if ( thisEventInfo->errorState(xAOD::EventInfo::EventFlagSubDet::Tile) == xAOD::EventInfo::Error ||
586  thisEventInfo->errorState(xAOD::EventInfo::EventFlagSubDet::LAr) == xAOD::EventInfo::Error ||
587  thisEventInfo->isEventFlagBitSet(xAOD::EventInfo::Core, 18) ) {
588  ATH_MSG_DEBUG("Event cleaning : skip event");
589  return StatusCode::SUCCESS;
590  }
591 
592  m_cutflow->Fill(1.);
593 
595  //* Get Pileup *//
597 
598  m_mu = lbInteractionsPerCrossing();
599  m_n_mu->Fill(m_mu);
600 
602  //* Trigger container *//
604 
605  if (m_use_trigdectool && m_jtmTrigDecTool != 0) { // only require trigger if m_use_trigdectool is true (false for express stream) and trigDecTool is ok
606 
607  ATH_MSG_DEBUG("TrigDecTool: " << m_jtmTrigDecTool);
608 
609  ATH_MSG_DEBUG("m_use_trigdectool: " << m_use_trigdectool << ", (m_jtmTrigDecTool->isPassed(" << m_ElectronTrigger_2016 << "): " << m_jtmTrigDecTool->isPassed(m_ElectronTrigger_2016));
610  ATH_MSG_DEBUG("m_use_trigdectool: " << m_use_trigdectool << ", (m_jtmTrigDecTool->isPassed(" << m_MuonTrigger_2016 << "): " << m_jtmTrigDecTool->isPassed(m_MuonTrigger_2016));
611 
612  ATH_MSG_DEBUG("m_use_trigdectool: " << m_use_trigdectool << ", (m_jtmTrigDecTool->isPassed(" << m_ElectronTrigger_2017 << "): " << m_jtmTrigDecTool->isPassed(m_ElectronTrigger_2017));
613  ATH_MSG_DEBUG("m_use_trigdectool: " << m_use_trigdectool << ", (m_jtmTrigDecTool->isPassed(" << m_MuonTrigger_2017 << "): " << m_jtmTrigDecTool->isPassed(m_MuonTrigger_2017));
614 
615  ATH_MSG_DEBUG("m_use_trigdectool: " << m_use_trigdectool << ", (m_jtmTrigDecTool->isPassed(" << m_ElectronTrigger_201X << "): " << m_jtmTrigDecTool->isPassed(m_ElectronTrigger_201X));
616  ATH_MSG_DEBUG("m_use_trigdectool: " << m_use_trigdectool << ", (m_jtmTrigDecTool->isPassed(" << m_MuonTrigger_201X << "): " << m_jtmTrigDecTool->isPassed(m_MuonTrigger_201X));
617 
618  auto chainGroup = m_jtmTrigDecTool->getChainGroup(".*");
619  for (auto & trig : chainGroup->getListOfTriggers()) {
620  ATH_MSG_DEBUG("Found trigger " << trig);
621  }
622 
623  m_trigPassed->Fill(0.);
624 
625  if(m_runNumber > 343000) // 2018 data
626  {
627  // 201X menu triggers
628  m_trigPassed->GetXaxis()->SetBinLabel(2,m_ElectronTrigger_201X.c_str());
629  m_trigPassed->GetXaxis()->SetBinLabel(3,m_MuonTrigger_201X.c_str());
630  m_trigPassed->GetXaxis()->SetBinLabel(4,(m_ElectronTrigger_201X+"_OR_"+m_MuonTrigger_201X).c_str());
631  m_trigPassed->GetXaxis()->SetBinLabel(5,(m_ElectronTrigger_201X+"_AND_"+m_MuonTrigger_201X).c_str());
632  m_trigPassed->GetXaxis()->SetBinLabel(6,"");
633  m_trigPassed->GetXaxis()->SetBinLabel(7,"");
634  m_trigPassed->GetXaxis()->SetBinLabel(8,"");
635  m_trigPassed->GetXaxis()->SetBinLabel(9,"");
636  // 201X menu triggers
637  if (m_jtmTrigDecTool->isPassed(m_ElectronTrigger_201X)) m_trigPassed->Fill(1.);
638  if (m_jtmTrigDecTool->isPassed(m_MuonTrigger_201X)) m_trigPassed->Fill(2.);
639  if (m_jtmTrigDecTool->isPassed(m_ElectronTrigger_201X) || m_jtmTrigDecTool->isPassed(m_MuonTrigger_201X)) m_trigPassed->Fill(3.);
640  if (m_jtmTrigDecTool->isPassed(m_ElectronTrigger_201X) && m_jtmTrigDecTool->isPassed(m_MuonTrigger_201X)) m_trigPassed->Fill(4.);
641  }
642  else
643  {
644  // 2016 menu
645  if (m_jtmTrigDecTool->isPassed(m_ElectronTrigger_2016)) m_trigPassed->Fill(1.);
646  if (m_jtmTrigDecTool->isPassed(m_MuonTrigger_2016)) m_trigPassed->Fill(2.);
647  if (m_jtmTrigDecTool->isPassed(m_ElectronTrigger_2016) && m_jtmTrigDecTool->isPassed(m_MuonTrigger_2016)) m_trigPassed->Fill(3.);
648  if (m_jtmTrigDecTool->isPassed(m_JetTrigger_2016)) m_trigPassed->Fill(4.);
649 
650  // 2017 menu
651  if (m_jtmTrigDecTool->isPassed(m_ElectronTrigger_2017)) m_trigPassed->Fill(5.);
652  if (m_jtmTrigDecTool->isPassed(m_MuonTrigger_2017)) m_trigPassed->Fill(6.);
653  if (m_jtmTrigDecTool->isPassed(m_ElectronTrigger_2017) && m_jtmTrigDecTool->isPassed(m_MuonTrigger_2017)) m_trigPassed->Fill(7.);
654  if (m_jtmTrigDecTool->isPassed(m_JetTrigger_2017)) m_trigPassed->Fill(8.);
655  }
656  }
657 
659  //* Primary vertex *//
661 
662  unsigned int npv = 0, npv_trk = 0;
663  double xpv = 0., ypv = 0., zpv = 0.;
664 
665  SG::ReadHandle<xAOD::VertexContainer> vxContainer{m_primaryVertexName};
666  if (!vxContainer.isValid()) {
667  ATH_MSG_WARNING("Unable to retrieve \"" << m_primaryVertexName.key() << "\" from StoreGate");
668  return StatusCode::SUCCESS;
669  }
670 
671  ATH_MSG_DEBUG("VxContainer \"" << m_primaryVertexName.key() << "\" found with " << vxContainer->size() << " entries");
672 
673  npv = vxContainer->size();
674  m_global_nPrimVtx->Fill((float)npv);
675 
676  if (vxContainer->size() < 2) {
677  ATH_MSG_WARNING("No primary vertices reconstructed");
678  return StatusCode::SUCCESS;
679  }
680 
681  m_cutflow->Fill(2.);
682 
683  bool foundVxTypePriVtx = false;
684  m_priVtx = nullptr;
685  for (xAOD::VertexContainer::const_iterator vtx = vxContainer->begin(); vtx != vxContainer->end(); ++vtx) {
686  if ((*vtx)->vertexType() == xAOD::VxType::PriVtx && (*vtx)->numberDoF() > 0 ) {
687  m_priVtx = *vtx;
688  foundVxTypePriVtx = true;
689  break;
690  }
691  }
692  if ( ! foundVxTypePriVtx ) {
693  ATH_MSG_WARNING("xAOD::Vertex of type xAOD::VxType::PriVtx was not found in vertex container.");
694  return StatusCode::SUCCESS;
695  }
696 
697  // if (m_priVtx->vxTrackAtVertexAvailable()) {
698  if (m_priVtx->nTrackParticles()>0) {
699  //npv_trk = m_priVtx->vxTrackAtVertex().size()
700  npv_trk = m_priVtx->nTrackParticles();
701  ATH_MSG_DEBUG("PV tracks: " << npv_trk);
702  }
703 
704  xpv = m_priVtx->x();
705  ypv = m_priVtx->y();
706  zpv = m_priVtx->z();
707 
708  ATH_MSG_DEBUG("primary vertex: x = " << xpv << ", y = " << ypv << ", z = " << zpv);
709 
710  if (xpv == 0 && ypv == 0 && zpv == 0)
711  ATH_MSG_WARNING("Primary Vertex is (0,0,0)");
712 
713  m_global_xPrimVtx->Fill(xpv);
714  m_global_yPrimVtx->Fill(ypv);
715  m_global_zPrimVtx->Fill(zpv);
716  m_priVtx_trks->Fill(npv_trk);
717 
718  // check first PV > 4 tracks, if not, fail
719  if ( npv_trk < m_pri_vtx_trk_min_cut )
720  return StatusCode::SUCCESS;
721 
722  m_cutflow->Fill(3.);
723 
724  // double vtxChiSq = primaryRecVertex.fitQuality().chiSquared();
725  // int vtxNDoF = primaryRecVertex.fitQuality().numberDoF();
726 
727  // double vtxProb = vtxChiSq / vtxNDoF;
728 
729 
730  if (m_use_trigdectool && m_jtmTrigDecTool != 0) { // only require trigger if m_use_trigdectool is true (will be false eg for express stream) and trigDecTool is ok
731  // Require emu tigger to have unbiased sample of jets (and larger fraction of b-jets since many of these are ttbar events)
732 
733  if(m_runNumber > 343000) // 2018 data
734  {
735  if (!m_jtmTrigDecTool->isPassed(m_ElectronTrigger_201X) && !m_jtmTrigDecTool->isPassed(m_MuonTrigger_201X)) // 201X menu triggers
736  return StatusCode::SUCCESS;
737  }
738  else
739  {
740  if (!m_jtmTrigDecTool->isPassed(m_ElectronTrigger_2016) && !m_jtmTrigDecTool->isPassed(m_MuonTrigger_2016) && // 2016 menu
741  !m_jtmTrigDecTool->isPassed(m_ElectronTrigger_2017) && !m_jtmTrigDecTool->isPassed(m_MuonTrigger_2017)) // 2017 menu
742  return StatusCode::SUCCESS;
743  }
744  }
745 
746  m_cutflow->Fill(4.);
747 
748  /* Fill Jet-based histograms */
749  fillJetHistograms();
750 
752  //* TrackParticle container *//
754 
755 
756  SG::ReadHandle<xAOD::TrackParticleContainer> trackParticles{m_trackParticleName};
757 
758  if (!trackParticles.isValid()) {
759  ATH_MSG_WARNING("Unable to retrieve \"" << m_trackParticleName.key() << "\" from StoreGate");
760  return StatusCode::SUCCESS;
761  }
762 
763  ATH_MSG_DEBUG("TrackParticleContainer \"" << m_trackParticleName.key() << "\" found with " << trackParticles->size() << " entries");
764 
765  xAOD::TrackParticleContainer::const_iterator trackParticleItr = trackParticles->begin();
766  xAOD::TrackParticleContainer::const_iterator trackParticleEnd = trackParticles->end();
767 
768  // New for Release 19: summary information is filled by reference, with a boolean Pass/Fail check...
769 
770  uint8_t nPixHits = 0;
771  uint8_t nSCTHits = 0;
772  uint8_t nSiHits = 0;
773  uint8_t nBLayerHits = 0; // IBL hits in Run-2, old b-layer in Run-1
774  uint8_t nTRTHits = 0;
775 
776  for ( ; trackParticleItr != trackParticleEnd; ++trackParticleItr) {
777 
778  if ((*trackParticleItr)->summaryValue(nBLayerHits, xAOD::numberOfBLayerHits)) { m_global_BLayerHits->Fill((float) nBLayerHits); } // IBL hits in Run-2, old b-layer in Run-1
779  if ((*trackParticleItr)->summaryValue(nPixHits, xAOD::numberOfPixelHits)) { m_global_PixelHits->Fill((float) nPixHits); }
780  if ((*trackParticleItr)->summaryValue(nSCTHits, xAOD::numberOfSCTHits)) { m_global_SCTHits->Fill((float) nSCTHits); }
781  if ((*trackParticleItr)->summaryValue(nTRTHits, xAOD::numberOfTRTHits)) { m_global_TRTHits->Fill((float) nTRTHits); }
782 
783  // too complicated to set up a check at this point... thank you framework!
784  nSiHits = nPixHits + nSCTHits;
785  m_global_SiHits->Fill((float)nSiHits);
786  nSiHits = 0; // clean up value for next round...
787  }
788 
789  m_trackParticle_n->Fill((*trackParticles).size());
790 
791  ATH_MSG_DEBUG("end of fillHistograms()");
792 
793  return StatusCode::SUCCESS;
794 }
795 
796 
797 bool JetTagMonitoring::passKinematicCuts(const xAOD::Jet *jet) {
798 
799  ATH_MSG_DEBUG("passKinematicCuts()");
800 
801  //* get jet basic kinematics *//
802  m_jet_eta->Fill(jet->eta());
803  m_jet_phi->Fill(jet->phi());
804  m_jet_et->Fill(jet->pt() / Gaudi::Units::GeV);
805 
806  ATH_MSG_DEBUG("Jet kinematics: eta = " << jet->eta() << ", phi= " << jet->phi() << ", pT= " << jet->pt() / Gaudi::Units::GeV);
807 
808 
809  // kinematic cuts defined as properties
810  if ( jet->pt() / Gaudi::Units::GeV < m_jet_pt_cut || fabs(jet->eta()) > m_jet_eta_cut )
811  return false;
812 
813  return true;
814 }
815 
816 
817 JetTagMonitoring::Jet_t JetTagMonitoring::getTaggabilityLabel(const xAOD::Jet *jet) {
818 
819  // goodJet = jet with at least one associated track passing track selection
820  // suspectJet = as good jet but
821  // badJet = not goodJet (i.e. no associated track passing track selection)
822 
823  ATH_MSG_DEBUG("in applyTaggabilityCuts()");
824 
825  /* if TrackSelector not used, return true */
826  if ( ! m_use_trackselector ) {
827  ATH_MSG_DEBUG("Not running track selection");
828  return goodJet;
829  }
830 
831  ATH_MSG_DEBUG("Running track selection");
832 
833  unsigned int nTrk = 0;
834 
835  // std::vector<InDet::TrackStateOnBLayerInfo> bInfo;
836  m_track_selector_all->Fill(jet->eta(), jet->phi(), 1.);
837  m_track_selector_all_LS->Fill(jet->eta(), jet->phi(), 1.);
838  //Work around, but compared to _all not needed.
839  // m_track_selector_eff->Fill(jet->eta(), jet->phi(), 1.);
840 
841  std::vector<const xAOD::IParticle*> trackVector = jet->getAssociatedObjects<xAOD::IParticle>(xAOD::JetAttribute::GhostTrack);
842 
843  bool isSuspectJet = false;
844 
845  std::vector<const xAOD::IParticle*>::const_iterator trkItr;
846 
847  for ( trkItr = trackVector.begin(); trkItr != trackVector.end() ; ++trkItr ) {
848 
849  const xAOD::TrackParticle* trackPart = dynamic_cast<const xAOD::TrackParticle*>(*trkItr);
850  if ( ! trackPart ) continue;
851 
852  double trk_eta = trackPart->eta();
853  double trk_phi = trackPart->phi();
854 
855  m_tracks_all_2D->Fill(trk_eta, trk_phi, 1.);
856  m_tracks_all_2D_LS->Fill(trk_eta, trk_phi, 1.);
857 
858  std::bitset<17> failedCuts;
859  if ( m_trackSelectorTool->selectTrack(m_priVtx->position(), trackPart, failedCuts) ) {
860 
861  m_tracks_passedCuts_2D->Fill(trk_eta, trk_phi);
862  nTrk++;
863 
864  } else {
865  const std::bitset<17> passedCuts = ~failedCuts;
866  fillBadTrackBits(passedCuts, trk_eta, trk_phi);
867 
868  if ( !passedCuts[deadBLayer] || !passedCuts[nHitBLayer] || !passedCuts[nHitSi] ) // if at least one associated track does not pass the deadBLayer, nHitBLayer or nSiHit requirement the jet will be labeled suspectJet
869  isSuspectJet = true;
870  }
871 
872  }
873  ATH_MSG_DEBUG("Good tracks: " << nTrk);
874 
875  if ( nTrk < m_trk_n ) return badJet;
876 
877  m_track_selector_eff->Fill(jet->eta(), jet->phi(), 1.); // added by SARA
878  m_track_selector_eff_LS->Fill(jet->eta(), jet->phi(), 1.);
879 
880  if ( isSuspectJet ) return suspectJet;
881 
882  return goodJet;
883 
884 }
885 
886 bool JetTagMonitoring::isTopEvent() { // added by SARA for 2017 data taking
887 
888  // DO TOP SELECTION
889  // == 1 isolated electron with pT > m_ElectronPtCut (normally 25 GeV)
890  // == 1 isolated muon with pT > m_MuonPtCut (normally 25 GeV)
891  // electron and muon of opposite charge
892 
893  SG::ReadHandle<xAOD::ElectronContainer> electrons{m_electronName};
894  if (!electrons.isValid()) {
895  ATH_MSG_WARNING("Unable to retrieve \"" << m_electronName.key() << "\" from StoreGate");
896  return false;
897  }
898 
899  ATH_MSG_DEBUG("ElectronContainer \"" << m_electronName.key() << "\" found with " << electrons->size() << " entries");
900 
901  xAOD::ElectronContainer::const_iterator electronItr = electrons->begin();
902  xAOD::ElectronContainer::const_iterator electronEnd = electrons->end();
903  xAOD::ElectronContainer::const_iterator isoElectronItr = electrons->end();
904 
905  SG::ReadHandle<xAOD::MuonContainer> muons{m_muonName};
906  if (!muons.isValid()) {
907  ATH_MSG_WARNING("Unable to retrieve \"" << m_muonName.key() << "\" from StoreGate");
908  return false;
909  }
910 
911  ATH_MSG_DEBUG("MuonContainer \"" << m_muonName.key() << "\" found with " << muons->size() << " entries");
912 
913  xAOD::MuonContainer::const_iterator muonItr = muons->begin();
914  xAOD::MuonContainer::const_iterator muonEnd = muons->end();
915  xAOD::MuonContainer::const_iterator isoMuonItr = muons->end();
916 
917  // loop over electron container
918  int n_isoElectrons = 0;
919  for ( ; electronItr != electronEnd; ++electronItr) {
920  //select electrons which passed author and pT cut
921  if (!(*electronItr)->author(xAOD::EgammaParameters::AuthorElectron)) continue;
922  if ((*electronItr) -> pt() / Gaudi::Units::GeV < m_ElectronPtCut) continue;
923  bool inAcceptance = (TMath::Abs((*electronItr) -> eta()) > m_ElectronEtaCrackHighCut || TMath::Abs((*electronItr) -> eta()) < m_ElectronEtaCrackLowCut)
924  && TMath::Abs((*electronItr) -> eta()) < m_ElectronEtaCut;
925  if (!inAcceptance) continue;
926  // select mediumLH electron
927  bool lhmedium = false;
928  (*electronItr)->passSelection(lhmedium, "LHMedium");
929  if (!lhmedium) continue;
930  //if ( electron -> isGoodOQ (xAOD::EgammaParameters::BADCLUSELECTRON) ) oq = true;
931  float topoetcone20_value = -999.;
932  float ptvarcone20_value = -999.;
933  (*electronItr)-> isolationValue(topoetcone20_value, xAOD::Iso::topoetcone20);
934  (*electronItr)-> isolationValue(ptvarcone20_value, xAOD::Iso::ptvarcone20);
935  if (topoetcone20_value/(*electronItr)->pt() > m_ElectronTopoEtCone20Cut) continue;
936  if (ptvarcone20_value/(*electronItr)->pt() > m_ElectronPtVarCone20Cut) continue;
937  isoElectronItr = electronItr;
938  ++n_isoElectrons;
939  }
940 
941  ATH_MSG_DEBUG("Number of isolated electrons is \"" << n_isoElectrons);
942  m_n_iso_el->Fill(n_isoElectrons);
943 
944  // loop over muon container
945  int n_isoMuons = 0;
946  for ( ; muonItr != muonEnd; ++muonItr) {
947  //select muons which passed pT cut
948  if ((*muonItr) -> pt() / Gaudi::Units::GeV < m_MuonPtCut) continue;
949  bool inAcceptance = TMath::Abs((*muonItr) -> eta()) < m_MuonEtaCut;
950  if (!inAcceptance) continue;
951 
952  if(m_runNumber > 343000) // 2018 data
953  {
954  // medium muons
955  if ((*muonItr)->quality() > 1) continue; // 0 tight, 1 medium, medium <= 1 (includes 0)
956  float topoetcone20_value = -999.;
957  float ptvarcone30_value = -999.;
958  (*muonItr)-> isolation(topoetcone20_value, xAOD::Iso::topoetcone20);
959  (*muonItr)-> isolation(ptvarcone30_value, xAOD::Iso::ptvarcone30);
960  if (topoetcone20_value/(*muonItr)->pt() > m_MuonTopoEtCone20Cut) continue;
961  if (ptvarcone30_value/(*muonItr)->pt() > m_MuonPtVarCone30Cut) continue;
962  }
963  else
964  { // medium muons
965  if ((*muonItr)->quality() != 1) continue; // 1 = medium muon
966  float topoetcone20_value = -999.;
967  float ptvarcone20_value = -999.;
968  (*muonItr)-> isolation(topoetcone20_value, xAOD::Iso::topoetcone20);
969  (*muonItr)-> isolation(ptvarcone20_value, xAOD::Iso::ptvarcone20);
970  if (topoetcone20_value/(*muonItr)->pt() > m_MuonTopoEtCone20Cut) continue;
971  if (ptvarcone20_value/(*muonItr)->pt() > m_MuonPtVarCone20Cut) continue;
972  }
973  isoMuonItr = muonItr;
974  ++n_isoMuons;
975  }
976 
977  ATH_MSG_DEBUG("Number of isolated muons is \"" << n_isoMuons);
978  m_n_iso_mu->Fill(n_isoMuons);
979 
980  // trying to understand what is going wrong
981  // require == 1 electron, == 1 muon and opposite charge
982  if (n_isoElectrons != 1) return false;
983  if (n_isoMuons != 1) return false;
984  if ((*isoElectronItr)->charge()*(*isoMuonItr)->charge() != -1.) return false;
985 
986  return true;
987 
988 }
989 
990 void JetTagMonitoring::fillEffHist(TH1 * h_passed, TH1 * h_all, TH1F_LW * effHist) {
991 
992  if ( TEfficiency::CheckConsistency(*h_passed, *h_all) ) {
993 
994  TEfficiency * eff = new TEfficiency(*h_passed, *h_all);
995  eff->SetStatisticOption(TEfficiency::kBJeffrey);
996 
997  for (int i = 1; i <= h_all->GetNbinsX(); ++i) {
998  effHist->SetBinContent( i , eff->GetEfficiency(i) );
999  effHist->SetBinError( i , (eff->GetEfficiencyErrorUp(i) + eff->GetEfficiencyErrorLow(i))/2. );
1000  }
1001 
1002  delete eff;
1003 
1004  }
1005 
1006 }
1007 
1008 StatusCode JetTagMonitoring::procHistograms() {
1009 
1010  ATH_MSG_DEBUG("in procHistograms()");
1011 
1012  /* Finalize the histograms */
1013  if ( m_histogramsCreated && (endOfRunFlag() || AthenaMonManager::environment() == AthenaMonManager::online) ) {
1014 
1015  //m_track_selector_eff->getROOTHist()->Divide(m_track_selector_all->getROOTHist(),m_tracks_all_2D->getROOTHist()); // removed by SARA
1016  m_track_selector_eff->getROOTHist()->Divide(m_track_selector_all->getROOTHist()); // added by SARA
1017  m_track_selector_eff_LS->getROOTHist()->Divide(m_track_selector_all_LS->getROOTHist()); // added by SARA
1018 
1019  m_jet_pt_top_eff->getROOTHist()->Divide(m_jet_pt_top_tagged->getROOTHist(),m_jet_pt_top->getROOTHist()); // added by SARA
1020  m_jet_top_eff->getROOTHist()->Divide(m_jet_top_tagged->getROOTHist(),m_jet_top->getROOTHist()); // added by SARA
1021 
1022  {
1023  TH1 * qualityJets_sum85OP = m_tag_mv_w_phi_sum85OP->getROOTHistBase();
1024  TH1 * qualityJets_sum77OP = m_tag_mv_w_phi_sum77OP->getROOTHistBase();
1025  TH1 * qualityJets_sum70OP = m_tag_mv_w_phi_sum70OP->getROOTHistBase();
1026  TH1 * qualityJets_sum60OP = m_tag_mv_w_phi_sum60OP->getROOTHistBase();
1027  TH1 * qualityJets_sumAll = m_tag_mv_w_phi_sumAll->getROOTHistBase();
1028 
1029  fillEffHist(qualityJets_sum85OP, qualityJets_sumAll, m_tag_mv_w_phi_frac85OP);
1030  fillEffHist(qualityJets_sum77OP, qualityJets_sumAll, m_tag_mv_w_phi_frac77OP);
1031  fillEffHist(qualityJets_sum70OP, qualityJets_sumAll, m_tag_mv_w_phi_frac70OP);
1032  fillEffHist(qualityJets_sum60OP, qualityJets_sumAll, m_tag_mv_w_phi_frac60OP);
1033  }
1034 
1035  {
1036  TH1 * qualityJets_sum85OP = m_tag_mv_w_eta_sum85OP->getROOTHistBase();
1037  TH1 * qualityJets_sum77OP = m_tag_mv_w_eta_sum77OP->getROOTHistBase();
1038  TH1 * qualityJets_sum70OP = m_tag_mv_w_eta_sum70OP->getROOTHistBase();
1039  TH1 * qualityJets_sum60OP = m_tag_mv_w_eta_sum60OP->getROOTHistBase();
1040  TH1 * qualityJets_sumAll = m_tag_mv_w_eta_sumAll->getROOTHistBase();
1041 
1042  fillEffHist(qualityJets_sum85OP, qualityJets_sumAll, m_tag_mv_w_eta_frac85OP);
1043  fillEffHist(qualityJets_sum77OP, qualityJets_sumAll, m_tag_mv_w_eta_frac77OP);
1044  fillEffHist(qualityJets_sum70OP, qualityJets_sumAll, m_tag_mv_w_eta_frac70OP);
1045  fillEffHist(qualityJets_sum60OP, qualityJets_sumAll, m_tag_mv_w_eta_frac60OP);
1046  }
1047 
1048  {
1049  TH1 * suspectJets_sum85OP = m_tag_mv_w_sj_phi_sum85OP->getROOTHistBase();
1050  TH1 * suspectJets_sum77OP = m_tag_mv_w_sj_phi_sum77OP->getROOTHistBase();
1051  TH1 * suspectJets_sum70OP = m_tag_mv_w_sj_phi_sum70OP->getROOTHistBase();
1052  TH1 * suspectJets_sum60OP = m_tag_mv_w_sj_phi_sum60OP->getROOTHistBase();
1053  TH1 * suspectJets_sumAll = m_tag_mv_w_sj_phi_sumAll->getROOTHistBase();
1054 
1055  fillEffHist(suspectJets_sum85OP, suspectJets_sumAll, m_tag_mv_w_sj_phi_frac85OP);
1056  fillEffHist(suspectJets_sum77OP, suspectJets_sumAll, m_tag_mv_w_sj_phi_frac77OP);
1057  fillEffHist(suspectJets_sum70OP, suspectJets_sumAll, m_tag_mv_w_sj_phi_frac70OP);
1058  fillEffHist(suspectJets_sum60OP, suspectJets_sumAll, m_tag_mv_w_sj_phi_frac60OP);
1059  }
1060 
1061  {
1062  TH1 * suspectJets_sum85OP = m_tag_mv_w_sj_eta_sum85OP->getROOTHistBase();
1063  TH1 * suspectJets_sum77OP = m_tag_mv_w_sj_eta_sum77OP->getROOTHistBase();
1064  TH1 * suspectJets_sum70OP = m_tag_mv_w_sj_eta_sum70OP->getROOTHistBase();
1065  TH1 * suspectJets_sum60OP = m_tag_mv_w_sj_eta_sum60OP->getROOTHistBase();
1066  TH1 * suspectJets_sumAll = m_tag_mv_w_sj_eta_sumAll->getROOTHistBase();
1067 
1068  fillEffHist(suspectJets_sum85OP, suspectJets_sumAll, m_tag_mv_w_sj_eta_frac85OP);
1069  fillEffHist(suspectJets_sum77OP, suspectJets_sumAll, m_tag_mv_w_sj_eta_frac77OP);
1070  fillEffHist(suspectJets_sum70OP, suspectJets_sumAll, m_tag_mv_w_sj_eta_frac70OP);
1071  fillEffHist(suspectJets_sum60OP, suspectJets_sumAll, m_tag_mv_w_sj_eta_frac60OP);
1072  }
1073 
1074  }
1075  ATH_MSG_DEBUG("Exiting from procHistograms()");
1076  return StatusCode::SUCCESS;
1077 }
1078 
1079 
1080 void JetTagMonitoring::fillJetHistograms() {
1081 
1082  ATH_MSG_DEBUG("in fillJetHistograms()");
1083 
1085  //* Jet container *//
1087 
1088  SG::ReadHandle<xAOD::JetContainer> jets{m_jetName};
1089  if (!jets.isValid()) {
1090  ATH_MSG_WARNING("Unable to retrieve \"" << m_jetName.key() << "\" from StoreGate");
1091  return;
1092  }
1093 
1094  ATH_MSG_DEBUG("JetContainer \"" << m_jetName.key() << "\" found with " << jets->size() << " entries");
1095 
1096  xAOD::JetContainer::const_iterator jetItr = jets->begin();
1097  xAOD::JetContainer::const_iterator jetEnd = jets->end();
1098 
1099  // Do top selection
1100  bool is_top_event = isTopEvent(); // added by SARA
1101 
1102  m_jet_n->Fill((*jets).size());
1103 
1104  int n_jets_kinematic = 0; // added by SARA
1105  xAOD::JetContainer::const_iterator firstKinematicjetItr = jets->end(); // added by SARA
1106 
1107  // Loop over jets
1108  for ( ; jetItr != jetEnd; ++jetItr) {
1109 
1110  // All jets
1111 
1112  m_cutflow_jet->Fill(0.); // all jets
1113 
1114  m_jet_2D_all->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
1115 
1116  if( !passJetQualityCuts(*jetItr) ) continue;
1117 
1118  // Jets passing quality cuts
1119 
1120  m_cutflow_jet->Fill(1.); // good jets (standard jet cleaning cuts)
1121 
1122  m_jet_2D_good->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
1123 
1124  if ( !passKinematicCuts(*jetItr) ) continue;
1125 
1126  // Jets passing kinemtic cuts
1127 
1128  m_cutflow_jet->Fill(2.); // jets passing kinematic cuts
1129 
1130  if(m_runNumber > 343000) // 2018 data
1131  {
1132  //Fix cutflow bin labels
1133  m_cutflow_jet->GetXaxis()->SetBinLabel(4,"Pass JVT cut");
1134  m_cutflow_jet->GetXaxis()->SetBinLabel(5,"Taggable");
1135  m_cutflow_jet->GetXaxis()->SetBinLabel(6,"Taggable Good");
1136  m_cutflow_jet->GetXaxis()->SetBinLabel(7,"Taggable Suspect");
1137 
1138  if ( !passJVTCuts(*jetItr) ) continue;
1139  // Jets passing JVT cuts
1140  m_cutflow_jet->Fill(3.); // passing JVT cuts (Jet Vertex Tagger, against pile-up jets)
1141  m_jet_2D_jvt->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
1142  }
1143 
1144  if (n_jets_kinematic == 0) firstKinematicjetItr = jetItr; // added by SARA - save this iterator since I will need to fill top histograms also for this 1st one if I find a 2nd kinematic jet later
1145  ++n_jets_kinematic; // added by SARA
1146 
1147  m_jet_2D_kinematic->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
1148  m_jet_2D_kinematic_LS->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
1149 
1150  fillTrackInJetHistograms(*jetItr); // fill histograms with properties of associated tracks
1151 
1152  if (is_top_event && n_jets_kinematic >= 2) { // added by SARA - I have at least 2 kinematic jets, so want to fill top histograms
1153  m_jet_top->Fill(0., 1.); // added by SARA
1154  m_jet_pt_top->Fill((*jetItr)->pt() / Gaudi::Units::GeV, 1.); // added by SARA
1155  if (n_jets_kinematic == 2) { // added by SARA - now I know I have (at least) two kinematic jets, so I want to fill also for 1st kinematic jet
1156  m_jet_top->Fill(0., 1.); // added by SARA
1157  m_jet_pt_top->Fill((*firstKinematicjetItr)->pt() / Gaudi::Units::GeV, 1.); // added by SARA
1158  }
1159  }
1160 
1161  fillBtagHistograms(*jetItr, false); // added by SARA; fill non-top histograms with b-tagging information (tag weights etc)
1162  if (is_top_event && n_jets_kinematic >= 2) { // added by SARA - I have at least 2 kinematic jets, so want to fill top histograms
1163  fillBtagHistograms(*jetItr, true); // added by SARA; fill histograms with b-tagging information (tag weights etc)
1164  if (n_jets_kinematic == 2) { // added by SARA - now I know I have (at least) two kinematic jets, so I want to fill also for 1st kinematic jet
1165  fillBtagHistograms(*firstKinematicjetItr, true); // added by SARA; fill histograms with b-tagging information (tag weights etc)
1166  }
1167  }
1168 
1169  Jet_t taggabilityLabel = getTaggabilityLabel(*jetItr); // check if jet is taggable (defined as goodJet or suspectJet)
1170 
1171  //if ( m_do_cuts && quality == badJet ) continue; // removed by SARA (otherwise we never fill the badJet histograms below)
1172 
1173 
1174  if ( taggabilityLabel == goodJet || taggabilityLabel == suspectJet ) {
1175  if(m_runNumber > 343000) // 2018 data
1176  {m_cutflow_jet->Fill(4.);} // added by SARA
1177  else
1178  {m_cutflow_jet->Fill(3.);} // added by SARA
1179  fillDetailedHistograms(*jetItr, taggabilityLabel); // SARA: added if statement to make sure we don't fill the detailed histograms for bad jets (since I removed the continue statement above)
1180  }
1181 
1182  if ( taggabilityLabel == goodJet ) {
1183  if(m_runNumber > 343000) // 2018 data
1184  {m_cutflow_jet->Fill(5.);} // added by SARA
1185  else
1186  {m_cutflow_jet->Fill(4.);} // added by SARA
1187  m_jet_2D_quality->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
1188  fillGoodJetHistos(*jetItr);
1189  }
1190  else if ( taggabilityLabel == suspectJet ) {
1191  if(m_runNumber > 343000) // 2018 data
1192  {m_cutflow_jet->Fill(6.);} // added by SARA
1193  else
1194  {m_cutflow_jet->Fill(5.);} // added by SARA
1195  m_jet_2D_suspect->Fill((*jetItr)->eta(), (*jetItr)->phi(), 1.);
1196  fillSuspectJetHistos(*jetItr);
1197  }
1198  else if ( taggabilityLabel == badJet ) {
1199  fillBadJetHistos(*jetItr);
1200  }
1201 
1202  }
1203 
1204  ATH_MSG_DEBUG("... done fillJetHistograms()");
1205  return;
1206 }
1207 
1208 void JetTagMonitoring::fillTrackInJetHistograms(const xAOD::Jet *jet) {
1209 
1210  ATH_MSG_DEBUG("in fillInJetTrackHistograms()");
1211 
1212  //* get information about Track Constituents *//
1213  int nTrkInJet = 0;
1214 
1215  std::vector<const xAOD::IParticle*> trackVector = jet->getAssociatedObjects<xAOD::IParticle>(xAOD::JetAttribute::GhostTrack);
1216 
1217  std::vector<const xAOD::IParticle*>::const_iterator trkItr;
1218 
1219  nTrkInJet = trackVector.size();
1220  ATH_MSG_DEBUG("examining " << nTrkInJet << " tracks.");
1221 
1222  // loop over tracks in a jet //
1223  for ( trkItr = trackVector.begin(); trkItr != trackVector.end() ; ++trkItr ) {
1224 
1225  const xAOD::TrackParticle* trackPart = dynamic_cast<const xAOD::TrackParticle*>(*trkItr);
1226  if ( ! trackPart ) continue;
1227 
1228  uint8_t nBLayerHits = 0; // IBL hits in Run-2, old b-layer in Run-1
1229  uint8_t nPixHits = 0;
1230  uint8_t nSCTHits = 0;
1231 
1232  m_jet_tracks_pt->Fill(trackPart->pt() / Gaudi::Units::GeV);
1233  m_jet_tracks_eta->Fill(trackPart->eta());
1234  m_jet_tracks_phi->Fill(trackPart->phi());
1235  m_jet_tracks_d0->Fill(trackPart->d0());
1236  m_jet_tracks_z0->Fill(trackPart->z0());
1237  m_jet_tracks_d0_LS->Fill(trackPart->d0());
1238  m_jet_tracks_z0_LS->Fill(trackPart->z0());
1239 
1240  if (trackPart->summaryValue(nBLayerHits, xAOD::numberOfBLayerHits)) { m_jet_tracks_BLayerHits->Fill((float) nBLayerHits); } // IBL hits in Run-2, old b-layer in Run-1
1241  if (trackPart->summaryValue(nPixHits, xAOD::numberOfPixelHits)) { m_jet_tracks_PixelHits->Fill((float) nPixHits); }
1242  if (trackPart->summaryValue(nSCTHits, xAOD::numberOfSCTHits)) { m_jet_tracks_SCTHits->Fill((float) nSCTHits); }
1243 
1244  }
1245 
1246  m_jet_tracks_n->Fill((float)nTrkInJet);
1247 
1248  return;
1249 }
1250 
1251 void JetTagMonitoring::fillBtagHistograms(const xAOD::Jet *jet, bool fill_top_histos) { // added by SARA (just moved already existing code into this function for better readibility)
1252 
1253  const xAOD::BTagging* btag = xAOD::BTaggingUtilities::getBTagging( *jet );
1254 
1255  if (!btag) return;
1256 
1257  double sv1ip3d = 0;
1258  double mv_tmp = 0;
1259  //btag->MVx_discriminant(m_mv_algorithmName,mv_tmp);
1260  double mv = mv_tmp;
1261 
1262  ATH_MSG_DEBUG("btagging weights: " << "SV1IP3D: " << sv1ip3d << ", MV: " << mv);
1263 
1264  if (fill_top_histos) { // added by SARA - fill top histograms
1265  m_jet_mv_w_top->Fill(mv); // added by SARA
1266  if (mv > m_mv_70_weight_cut) {
1267  m_jet_top_tagged->Fill(0., 1.); // added by SARA
1268  m_jet_pt_top_tagged->Fill(jet->pt() / Gaudi::Units::GeV, 1.); // added by SARA
1269  }
1270  }
1271  else { // added by SARA - fill non-top histograms
1272  /* fill the 2D SV1IP3D rate */
1273  if ( sv1ip3d > m_sv1ip3d_weight_cut ) {
1274  m_sv1ip3d_tag_pos_rate_2D->Fill(jet->eta(), jet->phi(), 1.);
1275  }
1276  else {
1277  m_sv1ip3d_tag_neg_rate_2D->Fill(jet->eta(), jet->phi(), 1.);
1278  }
1279 
1280  /* fill the 2D MV histos */
1281  if ( mv > m_mv_60_weight_cut ) m_mv_tag_60_2D->Fill(jet->eta(), jet->phi(), 1.);
1282  if ( mv > m_mv_70_weight_cut ) m_mv_tag_70_2D->Fill(jet->eta(), jet->phi(), 1.);
1283  if ( mv > m_mv_77_weight_cut ) m_mv_tag_77_2D->Fill(jet->eta(), jet->phi(), 1.);
1284  }
1285 
1286  return;
1287 
1288 }
1289 
1290 void JetTagMonitoring::fillDetailedHistograms(const xAOD::Jet *jet, Jet_t taggabilityLabel) {
1291 
1292  ATH_MSG_DEBUG("in fillDetailedHistograms()");
1293 
1294  //* get detailed information *//
1295  const xAOD::BTagging* btag = xAOD::BTaggingUtilities::getBTagging( *jet );
1296 
1297  if (not btag){
1298  ATH_MSG_WARNING("btag pointer is null in JetTagMonitoring::fillDetailedHistograms; filling these histograms will be skipped");
1299  return;
1300  }
1301  //* detailed information for impact parameter-based informations *//
1302  unsigned int ntrk = 0; // number of tracks used for tagging in the jet
1303  double pb = 0; // b likelihood
1304  double pu = 0; // u likelihood
1305  double pc = 0; // c likelihood
1306  double llr = 0; // log likelihood ratio
1307 
1308  if ( taggabilityLabel == goodJet ) {
1309  m_tag_ip3d_n->Fill((float)ntrk);
1310  m_tag_ip3d_b->Fill(pb);
1311  m_tag_ip3d_u->Fill(pu);
1312  m_tag_ip3d_c->Fill(pc);
1313  m_tag_ip3d_llr->Fill(llr);
1314  }
1315  else if ( taggabilityLabel == suspectJet ) {
1316  m_tag_ip3d_n_sj->Fill((float)ntrk);
1317  m_tag_ip3d_b_sj->Fill(pb);
1318  m_tag_ip3d_u_sj->Fill(pu);
1319  m_tag_ip3d_c_sj->Fill(pc);
1320  m_tag_ip3d_llr_sj->Fill(llr);
1321  }
1322 
1323  ATH_MSG_VERBOSE("InfoBase for IP3D: #tracks = " << ntrk << ", Pb = " << pb
1324  << ", Pu = " << pu<< ", Pc = " << pc << ", llr = " << llr);
1325 
1326  ntrk = 0; // number of tracks used for tagging in the jet
1327  pb = 0; // b likelihood
1328  pu = 0; // u likelihood
1329  pc = 0; // c likelihood
1330  llr = 0; // log likelihood ratio
1331 
1332  if ( taggabilityLabel == goodJet ) {
1333  m_tag_ip2d_n->Fill((float)ntrk);
1334  m_tag_ip2d_b->Fill(pb);
1335  m_tag_ip2d_u->Fill(pu);
1336  m_tag_ip2d_c->Fill(pc);
1337  m_tag_ip2d_llr->Fill(llr);
1338  }
1339  else if ( taggabilityLabel == suspectJet ) {
1340  m_tag_ip2d_n_sj->Fill((float)ntrk);
1341  m_tag_ip2d_b_sj->Fill(pb);
1342  m_tag_ip2d_u_sj->Fill(pu);
1343  m_tag_ip2d_c_sj->Fill(pc);
1344  m_tag_ip2d_llr_sj->Fill(llr);
1345  }
1346 
1347  ATH_MSG_VERBOSE("InfoBase for IP2D: #tracks = " << ntrk << ", Pb = " << pb
1348  << ", Pu = " << pu<< ", Pc = " << pc << ", llr = " << llr);
1349 
1350  float sig3d = 0;
1351  //btag->variable<float>("SV1", "significance3d" , sig3d);
1352  m_tag_sv0_sig3d->Fill(sig3d);
1353 
1354  pb = 0; // b likelihood
1355  pu = 0; // u likelihood
1356  pc = 0; // c likelihood
1357  llr = 0; // log likelihood ratio
1358 
1359  if ( taggabilityLabel == goodJet ) {
1360  m_tag_sv1_b->Fill(pb);
1361  m_tag_sv1_u->Fill(pu);
1362  m_tag_sv1_c->Fill(pc);
1363  m_tag_sv1_llr->Fill(llr);
1364  }
1365  else if ( taggabilityLabel == suspectJet ) {
1366  m_tag_sv1_b_sj->Fill(pb);
1367  m_tag_sv1_u_sj->Fill(pu);
1368  m_tag_sv1_c_sj->Fill(pc);
1369  m_tag_sv1_llr_sj->Fill(llr);
1370  }
1371 
1372  ATH_MSG_VERBOSE("InfoBase for SV1: Pb = " << pb << ", Pu = " << pu<< ", Pc = " << pc<< ", llr = " << llr);
1373 
1374  llr = 0; // log likelihood ratio
1375  if ( taggabilityLabel == goodJet ) {
1376  m_tag_jetfitter_llr->Fill(llr);
1377  }
1378  else if ( taggabilityLabel == suspectJet ) {
1379  m_tag_jetfitter_llr_sj->Fill(llr);
1380  }
1381 
1382  // log likelihood ratio
1383  llr = 0;
1384 
1385  if ( taggabilityLabel == goodJet ) {
1386  m_tag_jfcnn_llr->Fill(llr);
1387  }
1388  else if ( taggabilityLabel == suspectJet ) {
1389  m_tag_jfcnn_llr_sj->Fill(llr);
1390  }
1391 
1392  return;
1393 }
1394 
1395 
1396 void JetTagMonitoring::fillBadTrackBits(const std::bitset<17>& failedCuts, double eta, double phi) {
1397 
1398  if ( failedCuts[pTMin] == 0 ) m_tracks_pTMin_2D->Fill(eta, phi, 1.);
1399  if ( failedCuts[d0Max] == 0 ) m_tracks_d0Max_2D->Fill(eta, phi, 1.);
1400  if ( failedCuts[z0Max] == 0 ) m_tracks_z0Max_2D->Fill(eta, phi, 1.);
1401  if ( failedCuts[sigd0Max] == 0 ) m_tracks_sigd0Max_2D->Fill(eta, phi, 1.);
1402  if ( failedCuts[sigz0Max] == 0 ) m_tracks_sigz0Max_2D->Fill(eta, phi, 1.);
1403  if ( failedCuts[etaMax] == 0 ) m_tracks_etaMax_2D->Fill(eta, phi, 1.);
1404  if ( failedCuts[nHitBLayer] == 0 ) m_tracks_nHitBLayer_2D->Fill(eta, phi, 1.); // IBL hits in Run-2, old b-layer in Run-1
1405  if ( failedCuts[deadBLayer] == 0 ) m_tracks_deadBLayer_2D->Fill(eta, phi, 1.); // IBL hits in Run-2, old b-layer in Run-1
1406  if ( failedCuts[nHitPix] == 0 ) m_tracks_nHitPix_2D->Fill(eta, phi, 1.);
1407  if ( failedCuts[nHitSct] == 0 ) m_tracks_nHitSct_2D->Fill(eta, phi, 1.);
1408  if ( failedCuts[nHitSi] == 0 ) m_tracks_nHitSi_2D->Fill(eta, phi, 1.);
1409  if ( failedCuts[nHitTrt] == 0 ) m_tracks_nHitTrt_2D->Fill(eta, phi, 1.);
1410  if ( failedCuts[nHitTrtHighE] == 0 ) m_tracks_nHitTrtHighE_2D->Fill(eta, phi, 1.);
1411  if ( failedCuts[fitChi2] == 0 ) m_tracks_fitChi2_2D->Fill(eta, phi, 1.);
1412  if ( failedCuts[fitProb] == 0 ) m_tracks_fitProb_2D->Fill(eta, phi, 1.);
1413  if ( failedCuts[fitChi2OnNdfMax] == 0 ) m_tracks_fitChi2OnNdfMax_2D->Fill(eta, phi, 1.);
1414 
1415 
1416  if ( failedCuts[pTMin] == 0 ) m_tracks_pTMin_2D_LS->Fill(eta, phi, 1.);
1417  if ( failedCuts[d0Max] == 0 ) m_tracks_d0Max_2D_LS->Fill(eta, phi, 1.);
1418  if ( failedCuts[z0Max] == 0 ) m_tracks_z0Max_2D_LS->Fill(eta, phi, 1.);
1419  if ( failedCuts[sigd0Max] == 0 ) m_tracks_sigd0Max_2D_LS->Fill(eta, phi, 1.);
1420  if ( failedCuts[sigz0Max] == 0 ) m_tracks_sigz0Max_2D_LS->Fill(eta, phi, 1.);
1421  if ( failedCuts[etaMax] == 0 ) m_tracks_etaMax_2D_LS->Fill(eta, phi, 1.);
1422  if ( failedCuts[nHitBLayer] == 0 ) m_tracks_nHitBLayer_2D_LS->Fill(eta, phi, 1.); // IBL hits in Run-2, old b-layer in Run-1
1423  if ( failedCuts[deadBLayer] == 0 ) m_tracks_deadBLayer_2D_LS->Fill(eta, phi, 1.); // IBL hits in Run-2, old b-layer in Run-1
1424  if ( failedCuts[nHitPix] == 0 ) m_tracks_nHitPix_2D_LS->Fill(eta, phi, 1.);
1425  if ( failedCuts[nHitSct] == 0 ) m_tracks_nHitSct_2D_LS->Fill(eta, phi, 1.);
1426  if ( failedCuts[nHitSi] == 0 ) m_tracks_nHitSi_2D_LS->Fill(eta, phi, 1.);
1427  if ( failedCuts[nHitTrt] == 0 ) m_tracks_nHitTrt_2D_LS->Fill(eta, phi, 1.);
1428  if ( failedCuts[nHitTrtHighE] == 0 ) m_tracks_nHitTrtHighE_2D_LS->Fill(eta, phi, 1.);
1429  if ( failedCuts[fitChi2] == 0 ) m_tracks_fitChi2_2D_LS->Fill(eta, phi, 1.);
1430  if ( failedCuts[fitProb] == 0 ) m_tracks_fitProb_2D_LS->Fill(eta, phi, 1.);
1431  if ( failedCuts[fitChi2OnNdfMax] == 0 ) m_tracks_fitChi2OnNdfMax_2D_LS->Fill(eta, phi, 1.);
1432 
1433 
1434  return;
1435 
1436 }
1437 
1438 void JetTagMonitoring::fillGoodJetHistos(const xAOD::Jet *jet) {
1439 
1440  const xAOD::BTagging* btag = xAOD::BTaggingUtilities::getBTagging( *jet );
1441  if (not btag){
1442  ATH_MSG_WARNING("btag pointer is null in JetTagMonitoring::fillGoodJetHistos; filling these histograms will be skipped");
1443  return;
1444  }
1445  double sv1ip3d = 0;
1446  double mv_tmp = 0;
1447  //btag->MVx_discriminant(m_mv_algorithmName,mv_tmp);
1448  double mv = mv_tmp;
1449 
1450  m_tag_sv1ip3d_w->Fill(sv1ip3d);
1451  m_tag_mv_w->Fill(mv);
1452  m_tag_mv_w_LS->Fill(mv);
1453 
1454  // Plots Tagger in pile up bins
1455  double mu = m_mu;
1456 
1457  if ( mu > 0. && mu < 30. ) m_tag_mv_w_mu0_30->Fill(mv);
1458  else if ( mu > 30. && mu < 50. ) m_tag_mv_w_mu30_50->Fill(mv);
1459  else if ( mu > 50. && mu < 70. ) m_tag_mv_w_mu50_70->Fill(mv);
1460 
1461  if ( jet->pt() / Gaudi::Units::GeV > 200. ) m_tag_mv_w_pT200->Fill(mv);
1462  else if ( jet->pt() / Gaudi::Units::GeV > 100. ) m_tag_mv_w_pT100_200->Fill(mv);
1463  else if ( jet->pt() / Gaudi::Units::GeV > 50. ) m_tag_mv_w_pT50_100->Fill(mv);
1464  else if ( jet->pt() / Gaudi::Units::GeV > 20. ) m_tag_mv_w_pT20_50->Fill(mv);
1465  else if ( jet->pt() / Gaudi::Units::GeV > 10. ) m_tag_mv_w_pT10_20->Fill(mv);
1466 
1467  if ( jet->pt() / Gaudi::Units::GeV > 200. ) m_tag_mv_w_pT200_LS->Fill(mv);
1468  else if ( jet->pt() / Gaudi::Units::GeV > 100. ) m_tag_mv_w_pT100_200_LS->Fill(mv);
1469  else if ( jet->pt() / Gaudi::Units::GeV > 50. ) m_tag_mv_w_pT50_100_LS->Fill(mv);
1470  else if ( jet->pt() / Gaudi::Units::GeV > 20. ) m_tag_mv_w_pT20_50_LS->Fill(mv);
1471  else if ( jet->pt() / Gaudi::Units::GeV > 10. ) m_tag_mv_w_pT10_20_LS->Fill(mv);
1472 
1473 
1474  if ( fabs(jet->eta()) > 2.0 ) m_tag_mv_w_eta20_25->Fill(mv);
1475  else if ( fabs(jet->eta()) > 1.5 ) m_tag_mv_w_eta15_20->Fill(mv);
1476  else if ( fabs(jet->eta()) > 1.0 ) m_tag_mv_w_eta10_15->Fill(mv);
1477  else if ( fabs(jet->eta()) > 0.5 ) m_tag_mv_w_eta05_10->Fill(mv);
1478  else m_tag_mv_w_eta0_05->Fill(mv);
1479 
1480  if ( fabs(jet->phi()) > 2.8 ) m_tag_mv_w_phi28->Fill(mv);
1481  else if ( fabs(jet->phi()) > 2.1 ) m_tag_mv_w_phi21_28->Fill(mv);
1482  else if ( fabs(jet->phi()) > 1.4 ) m_tag_mv_w_phi14_21->Fill(mv);
1483  else if ( fabs(jet->phi()) > 0.7 ) m_tag_mv_w_phi07_14->Fill(mv);
1484  else m_tag_mv_w_phi0_07->Fill(mv);
1485 
1486  // if ( mv > -0.7887 ) {
1487  if ( mv > m_mv_85_weight_cut ) {
1488  m_tag_mv_w_phi_sum85OP->Fill(jet->phi());
1489  m_tag_mv_w_eta_sum85OP->Fill(jet->eta());
1490  }
1491  // if ( mv > -0.4434 ) {
1492  if ( mv > m_mv_77_weight_cut ) {
1493  m_tag_mv_w_phi_sum77OP->Fill(jet->phi());
1494  m_tag_mv_w_eta_sum77OP->Fill(jet->eta());
1495  }
1496  // if ( mv > -0.0436 ) {
1497  if ( mv > m_mv_70_weight_cut ) {
1498  m_tag_mv_w_phi_sum70OP->Fill(jet->phi());
1499  m_tag_mv_w_eta_sum70OP->Fill(jet->eta());
1500  }
1501  // if ( mv > 0.7535 ) {
1502  if ( mv > m_mv_60_weight_cut ) {
1503  m_tag_mv_w_phi_sum60OP->Fill(jet->phi());
1504  m_tag_mv_w_eta_sum60OP->Fill(jet->eta());
1505  }
1506  m_tag_mv_w_phi_sumAll->Fill(jet->phi());
1507  m_tag_mv_w_eta_sumAll->Fill(jet->eta());
1508 
1509  return;
1510 
1511 }
1512 
1513 /* should mimick as close as possible the same function from Reconstruction/Jet/JetMonitoring/src/JetRecMonToolBase.cxx */
1514 
1515 bool JetTagMonitoring::passJetQualityCuts(const xAOD::Jet *jet){
1516 
1517  if (msgLvl(MSG::DEBUG))
1518  ATH_MSG_DEBUG("in dq cleaning cuts JetTagMon");
1519 
1520  bool pass_cuts = false;
1521 
1522  float jetQuality = jet->getAttribute<float>(xAOD::JetAttribute::LArQuality);
1523  float jetTime = jet->getAttribute<float>(xAOD::JetAttribute::Timing);
1524  float hecq = jet->getAttribute<float>(xAOD::JetAttribute::HECQuality);
1525  float negE = jet->getAttribute<float>(xAOD::JetAttribute::NegativeE);
1526  std::vector<float> SumPtTrkPt1000;
1527  jet->getAttribute(xAOD::JetAttribute::SumPtTrkPt1000,SumPtTrkPt1000);
1528  float chf = SumPtTrkPt1000.size() > 0 ? SumPtTrkPt1000.at(0)/jet->pt() : -1;
1529  float emf = jet->getAttribute<float>(xAOD::JetAttribute::EMFrac);
1530  float hecf = jet->getAttribute<float>(xAOD::JetAttribute::HECFrac);
1531  //int SamplingMax = CaloSampling::Unknown;
1532  float fracSamplingMax = jet->getAttribute<float>(xAOD::JetAttribute::FracSamplingMax);
1533 
1534  if (
1535  !(
1536  (hecf>0.5 && fabs(hecq)>0.5) || (fabs(negE) > 60*Gaudi::Units::GeV) ||
1537  (emf>0.95 && fabs(jetQuality)>0.8 && fabs(jet->eta()) < 2.8) ||
1538  //(n90<=5 && hecf>0.8) || (hecf>0.5 && fabs(jetQuality)>0.5) || (emf<0.05) ||
1539  (fabs(jetTime)>25) ||
1540  (emf<0.05 && chf<0.05 && fabs(jet->eta())<2) ||
1541  (emf<0.05 && fabs(jet->eta())>= 2) ||
1542  (fracSamplingMax>0.99 && fabs(jet->eta())<2)
1543  )
1544  ){
1545  pass_cuts = true;
1546  }
1547 
1548  return pass_cuts;
1549 
1550 }
1551 
1552 
1553 void JetTagMonitoring::fillSuspectJetHistos(const xAOD::Jet *jet) {
1554 
1555  m_track_selector_suspect->Fill(jet->eta(), jet->phi(), 1.);
1556 
1557  const xAOD::BTagging* btag = xAOD::BTaggingUtilities::getBTagging( *jet );
1558  if (not btag){
1559  ATH_MSG_WARNING("btag pointer is null in JetTagMonitoring::fillSuspectJetHistos; filling these histograms will be skipped");
1560  return;
1561  }
1562  double sv1ip3d = 0;
1563  double mv_tmp = 0;
1564  //btag->MVx_discriminant(m_mv_algorithmName,mv_tmp);
1565  double mv = mv_tmp;
1566 
1567  m_tag_sv1ip3d_w_sj->Fill(sv1ip3d);
1568  m_tag_mv_w_sj->Fill(mv);
1569 
1570  if ( jet->pt() / Gaudi::Units::GeV > 200. ) m_tag_mv_w_sj_pT200->Fill(mv);
1571  else if ( jet->pt() / Gaudi::Units::GeV > 100. ) m_tag_mv_w_sj_pT100_200->Fill(mv);
1572  else if ( jet->pt() / Gaudi::Units::GeV > 50. ) m_tag_mv_w_sj_pT50_100->Fill(mv);
1573  else if ( jet->pt() / Gaudi::Units::GeV > 20. ) m_tag_mv_w_sj_pT20_50->Fill(mv);
1574  else if ( jet->pt() / Gaudi::Units::GeV > 10. ) m_tag_mv_w_sj_pT10_20->Fill(mv);
1575 
1576  if ( fabs(jet->eta()) > 2.0 ) m_tag_mv_w_sj_eta20_25->Fill(mv);
1577  else if ( fabs(jet->eta()) > 1.5 ) m_tag_mv_w_sj_eta15_20->Fill(mv);
1578  else if ( fabs(jet->eta()) > 1.0 ) m_tag_mv_w_sj_eta10_15->Fill(mv);
1579  else if ( fabs(jet->eta()) > 0.5 ) m_tag_mv_w_sj_eta05_10->Fill(mv);
1580  else m_tag_mv_w_sj_eta0_05->Fill(mv);
1581 
1582  if ( fabs(jet->phi()) > 2.8 ) m_tag_mv_w_sj_phi28->Fill(mv);
1583  else if ( fabs(jet->phi()) > 2.1 ) m_tag_mv_w_sj_phi21_28->Fill(mv);
1584  else if ( fabs(jet->phi()) > 1.4 ) m_tag_mv_w_sj_phi14_21->Fill(mv);
1585  else if ( fabs(jet->phi()) > 0.7 ) m_tag_mv_w_sj_phi07_14->Fill(mv);
1586  else m_tag_mv_w_sj_phi0_07->Fill(mv);
1587 
1588  // if ( mv > -0.7887 ) {
1589  if ( mv > m_mv_85_weight_cut ) {
1590  m_tag_mv_w_sj_phi_sum85OP->Fill(jet->phi());
1591  m_tag_mv_w_sj_eta_sum85OP->Fill(jet->eta());
1592  }
1593  // if ( mv > -0.4434 ) {
1594  if ( mv > m_mv_77_weight_cut ) {
1595  m_tag_mv_w_sj_phi_sum77OP->Fill(jet->phi());
1596  m_tag_mv_w_sj_eta_sum77OP->Fill(jet->eta());
1597  }
1598  // if ( mv > -0.0436 ) {
1599  if ( mv > m_mv_70_weight_cut ) {
1600  m_tag_mv_w_sj_phi_sum70OP->Fill(jet->phi());
1601  m_tag_mv_w_sj_eta_sum70OP->Fill(jet->eta());
1602  }
1603  // if ( mv > 0.7535 ) {
1604  if ( mv > m_mv_60_weight_cut ) {
1605  m_tag_mv_w_sj_phi_sum60OP->Fill(jet->phi());
1606  m_tag_mv_w_sj_eta_sum60OP->Fill(jet->eta());
1607  }
1608  m_tag_mv_w_sj_phi_sumAll->Fill(jet->phi());
1609  m_tag_mv_w_sj_eta_sumAll->Fill(jet->eta());
1610 
1611  return;
1612 
1613 }
1614 
1615 
1616 void JetTagMonitoring::fillBadJetHistos(const xAOD::Jet *jet) {
1617 
1618  m_jet_2D_bad->Fill(jet->eta(), jet->phi(), 1.);
1619 
1620  return;
1621 
1622 }
1623 
1624 bool JetTagMonitoring::passJVTCuts(const xAOD::Jet *jet) {
1625 
1626  ATH_MSG_DEBUG("passJVTCuts()");
1627 
1628  static const SG::AuxElement::Accessor<float> JVT( "Jvt" ); //JVT > 0.59 (60 GeV)
1629  double jvt = JVT(*jet);
1630 
1631  if( !( ((jet->pt()<60000)&&(abs(jet->eta())<2.4)&&(jvt > 0.59))||((jet->pt()<60000)&&(abs(jet->eta())>2.4))||(jet->pt()>60000) ) ) return false;
1632 
1633  return true;
1634 }
1635 
1636 
1637 /*
1638  void JetTagMonitoring::fillBadZone(int zone, double ip3d) {
1639 
1640  if( zone == 1 ) {
1641  m_tag_ip3d_w_DMZ2_x1->Fill(ip3d, 1.);
1642  m_tag_ip3d_w_DMZ2_x2->Fill(ip3d, 1.);
1643  m_tag_ip3d_w_DMZ2_x4->Fill(ip3d, 1.);
1644  m_tag_ip3d_w_DMZ2_x8->Fill(ip3d, 1.);
1645 
1646  m_tag_ip3d_w_DMZ3_x1->Fill(ip3d, 1.);
1647  m_tag_ip3d_w_DMZ3_x2->Fill(ip3d, 1.);
1648  m_tag_ip3d_w_DMZ3_x4->Fill(ip3d, 1.);
1649  m_tag_ip3d_w_DMZ3_x8->Fill(ip3d, 1.);
1650  }
1651  else if ( zone == 2 ) {
1652  m_tag_ip3d_w_DMZ2_x1->Fill(ip3d, 1.);
1653  m_tag_ip3d_w_DMZ2_x2->Fill(ip3d, 2.);
1654  m_tag_ip3d_w_DMZ2_x4->Fill(ip3d, 4.);
1655  m_tag_ip3d_w_DMZ2_x8->Fill(ip3d, 8.);
1656 
1657  m_tag_ip3d_w_DMZ3_x1->Fill(ip3d, 1.);
1658  m_tag_ip3d_w_DMZ3_x2->Fill(ip3d, 1.);
1659  m_tag_ip3d_w_DMZ3_x4->Fill(ip3d, 1.);
1660  m_tag_ip3d_w_DMZ3_x8->Fill(ip3d, 1.);
1661  }
1662  else if ( zone == 3 ) {
1663  m_tag_ip3d_w_DMZ2_x1->Fill(ip3d, 1.);
1664  m_tag_ip3d_w_DMZ2_x2->Fill(ip3d, 1.);
1665  m_tag_ip3d_w_DMZ2_x4->Fill(ip3d, 1.);
1666  m_tag_ip3d_w_DMZ2_x8->Fill(ip3d, 1.);
1667 
1668  m_tag_ip3d_w_DMZ3_x1->Fill(ip3d, 1.);
1669  m_tag_ip3d_w_DMZ3_x2->Fill(ip3d, 2.);
1670  m_tag_ip3d_w_DMZ3_x4->Fill(ip3d, 4.);
1671  m_tag_ip3d_w_DMZ3_x8->Fill(ip3d, 8.);
1672  }
1673 
1674  return;
1675 
1676  }
1677 */
1678 
1679 //void JetTagMonitoring::fillTopHistograms() {
1680 
1681 //return;
1682 
1683 //}
JetTagMonitoring::m_mv_tag_70_2D
TH2F_LW * m_mv_tag_70_2D
Definition: JetTagMonitoring.h:405
TH2F_LW::Fill
virtual void Fill(const double &x, const double &y) override
Definition: TH2F_LW.cxx:329
JetTagMonitoring::m_tag_sv1_u_sj
TH1F_LW * m_tag_sv1_u_sj
Definition: JetTagMonitoring.h:205
JetTagMonitoring::nHitPix
@ nHitPix
Definition: JetTagMonitoring.h:416
LWHist
Definition: LWHist.h:26
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
JetTagMonitoring::m_mv_tag_77_2D
TH2F_LW * m_mv_tag_77_2D
Definition: JetTagMonitoring.h:406
JetTagMonitoring::m_n_mu
TH1F_LW * m_n_mu
NEW 2018: jets taggers in pileup bins histograms.
Definition: JetTagMonitoring.h:461
JetTagMonitoring::m_tag_mv_w_eta0_05
TH1F_LW * m_tag_mv_w_eta0_05
Definition: JetTagMonitoring.h:237
BTaggingUtilities.h
JetTagMonitoring::m_jet_et
TH1F_LW * m_jet_et
To monitor Et of the reconstructed jet.
Definition: JetTagMonitoring.h:329
xAOD::Iso::ptvarcone30
@ ptvarcone30
Definition: IsolationType.h:56
JetTagMonitoring::m_tag_mv_w_sj_eta_frac60OP
TH1F_LW * m_tag_mv_w_sj_eta_frac60OP
Definition: JetTagMonitoring.h:298
JetTagMonitoring::fillDetailedHistograms
void fillDetailedHistograms(const xAOD::Jet *jet, Jet_t taggabilityLabel)
Definition: JetTagMonitoring.cxx:1290
xAOD::Vertex_v1::x
float x() const
Returns the x position.
JetTagMonitoring::m_tag_mv_w_sj_phi_frac85OP
TH1F_LW * m_tag_mv_w_sj_phi_frac85OP
Definition: JetTagMonitoring.h:286
JetTagMonitoring::registerHist
void registerHist(MonGroup &theGroup, TH1 *h1)
Definition: JetTagMonitoring.cxx:100
JetTagMonitoring::fitChi2OnNdfMax
@ fitChi2OnNdfMax
Definition: JetTagMonitoring.h:417
JetTagMonitoring::m_n_iso_mu
TH1F_LW * m_n_iso_mu
Definition: JetTagMonitoring.h:363
JetTagMonitoring::m_tag_ip3d_c
TH1F_LW * m_tag_ip3d_c
To monitor jet likelihood value if coming from c decay for IP3D tagger.
Definition: JetTagMonitoring.h:193
JetTagMonitoring::m_jet_top_eff
TH1F_LW * m_jet_top_eff
Definition: JetTagMonitoring.h:387
JetTagMonitoring::m_tracks_sigd0Max_2D_LS
TH2F_LW * m_tracks_sigd0Max_2D_LS
Definition: JetTagMonitoring.h:446
JetTagMonitoring::suspectJet
@ suspectJet
Definition: JetTagMonitoring.h:82
JetTagMonitoring::m_tag_ip2d_b_sj
TH1F_LW * m_tag_ip2d_b_sj
Definition: JetTagMonitoring.h:173
TH1F_LW.h
JetTagMonitoring::m_global_TRTHits
TH1F_LW * m_global_TRTHits
To monitor number of TRT hits in TrackParticle.
Definition: JetTagMonitoring.h:322
TH2F_LW.h
JetTagMonitoring::m_jet_pt_cut
double m_jet_pt_cut
Definition: JetTagMonitoring.h:130
JetTagMonitoring::m_global_nPrimVtx
TH1F_LW * m_global_nPrimVtx
To monitor number of primary vertices.
Definition: JetTagMonitoring.h:305
JetTagMonitoring::m_tracks_fitChi2_2D_LS
TH2F_LW * m_tracks_fitChi2_2D_LS
Definition: JetTagMonitoring.h:456
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
JetTagMonitoring::m_tracks_nHitPix_2D_LS
TH2F_LW * m_tracks_nHitPix_2D_LS
Definition: JetTagMonitoring.h:451
JetTagMonitoring::m_tag_sv1ip3d_w
TH1F_LW * m_tag_sv1ip3d_w
To monitor likelihood weight based on combined tagger (IP3D+SV1).
Definition: JetTagMonitoring.h:220
xAOD::Iso::topoetcone20
@ topoetcone20
Topo-cluster ET-sum.
Definition: IsolationType.h:48
JetTagMonitoring::m_jet_mv_w_top
TH1F_LW * m_jet_mv_w_top
Definition: JetTagMonitoring.h:382
JetTagMonitoring::m_global_zPrimVtx
TH1F_LW * m_global_zPrimVtx
To monitor z of primary vertex.
Definition: JetTagMonitoring.h:311
xAOD::Iso::ptvarcone20
@ ptvarcone20
Mini-Isolation http://arxiv.org/abs/1007.2221.
Definition: IsolationType.h:55
xAOD::Vertex_v1::nTrackParticles
size_t nTrackParticles() const
Get the number of tracks associated with this vertex.
Definition: Vertex_v1.cxx:270
JetTagMonitoring::m_tracks_d0Max_2D
TH2F_LW * m_tracks_d0Max_2D
Definition: JetTagMonitoring.h:424
JetTagMonitoring::fitProb
@ fitProb
Definition: JetTagMonitoring.h:417
xAOD::JetAttribute::LArQuality
@ LArQuality
Definition: JetAttributes.h:83
TH1F_LW::SetBinError
virtual void SetBinError(unsigned bin, const double &) override
Definition: TH1F_LW.cxx:268
JetTagMonitoring::m_tracks_pTMin_2D
TH2F_LW * m_tracks_pTMin_2D
Definition: JetTagMonitoring.h:423
JetTagMonitoring::m_tag_mv_w_pT10_20_LS
TH1F_LW * m_tag_mv_w_pT10_20_LS
Definition: JetTagMonitoring.h:231
JetTagMonitoring::m_ElectronEtaCrackLowCut
double m_ElectronEtaCrackLowCut
Definition: JetTagMonitoring.h:143
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
xAOD::JetAttribute::FracSamplingMax
@ FracSamplingMax
Definition: JetAttributes.h:116
JetTagMonitoring::m_pri_vtx_trk_min_cut
unsigned int m_pri_vtx_trk_min_cut
Definition: JetTagMonitoring.h:129
TH1F_LW::Fill
virtual void Fill(const double &x) override
Definition: TH1F_LW.cxx:246
keylayer_zslicemap.pb
pb
Definition: keylayer_zslicemap.py:188
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
JetTagMonitoring::m_tag_mv_w_sj_phi07_14
TH1F_LW * m_tag_mv_w_sj_phi07_14
Definition: JetTagMonitoring.h:277
BTagging.h
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
JetTagMonitoring::sigz0Max
@ sigz0Max
Definition: JetTagMonitoring.h:415
JetTagMonitoring::m_jet_eta
TH1F_LW * m_jet_eta
To monitor eta of the reconstructed jet.
Definition: JetTagMonitoring.h:325
JetTagMonitoring::m_tag_mv_w_eta_frac70OP
TH1F_LW * m_tag_mv_w_eta_frac70OP
Definition: JetTagMonitoring.h:263
JetTagMonitoring::m_sv1ip3d_weight_cut
double m_sv1ip3d_weight_cut
Definition: JetTagMonitoring.h:133
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:66
TH1F_LW::create
static TH1F_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xlow, const double &xup)
Definition: TH1F_LW.cxx:33
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:74
JetTagMonitoring::m_cutflow_jet
TH1F_LW * m_cutflow_jet
Definition: JetTagMonitoring.h:368
JetTagMonitoring::fillEffHist
void fillEffHist(TH1 *h_passed, TH1 *h_all, TH1F_LW *effHist)
Definition: JetTagMonitoring.cxx:990
JetTagMonitoring::m_mu
double m_mu
Definition: JetTagMonitoring.h:469
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
JetTagMonitoring::m_primaryVertexName
SG::ReadHandleKey< xAOD::VertexContainer > m_primaryVertexName
String to retrieve PrimaryVertexContainer from StoreGate.
Definition: JetTagMonitoring.h:117
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
JetTagMonitoring::m_ElectronEtaCrackHighCut
double m_ElectronEtaCrackHighCut
Definition: JetTagMonitoring.h:144
JetTagMonitoring::m_tag_mv_w_sj_eta_sum77OP
TH1F_LW * m_tag_mv_w_sj_eta_sum77OP
Definition: JetTagMonitoring.h:291
TH1F_LW::getROOTHist
TH1F * getROOTHist()
Definition: TH1F_LW.cxx:145
JetTagMonitoring::m_tag_mv_w_sj_phi_frac60OP
TH1F_LW * m_tag_mv_w_sj_phi_frac60OP
Definition: JetTagMonitoring.h:289
JetTagMonitoring::m_track_selector_eff_LS
TH2F_LW * m_track_selector_eff_LS
Definition: JetTagMonitoring.h:374
JetTagMonitoring::m_histogramsCreated
bool m_histogramsCreated
Definition: JetTagMonitoring.h:107
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
JetTagMonitoring::m_tag_mv_w_eta_sum77OP
TH1F_LW * m_tag_mv_w_eta_sum77OP
Definition: JetTagMonitoring.h:257
JetTagMonitoring::m_tag_jfcnn_llr
TH1F_LW * m_tag_jfcnn_llr
To monitor log likelihood ratio for combined tagger JetFitterCOMBNN.
Definition: JetTagMonitoring.h:216
JetTagMonitoring::m_tag_sv1_b
TH1F_LW * m_tag_sv1_b
To monitor jet likelihood value if coming from b decay for SV1 tagger.
Definition: JetTagMonitoring.h:201
JetTagMonitoring::m_tracks_nHitTrtHighE_2D
TH2F_LW * m_tracks_nHitTrtHighE_2D
Definition: JetTagMonitoring.h:435
JetTagMonitoring::getTaggabilityLabel
Jet_t getTaggabilityLabel(const xAOD::Jet *jet)
Definition: JetTagMonitoring.cxx:817
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:736
AthenaMonManager::cosmics
@ cosmics
Definition: AthenaMonManager.h:58
JetTagMonitoring::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: JetTagMonitoring.cxx:1008
JetTagMonitoring::m_jetBtagKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_jetBtagKey
Definition: JetTagMonitoring.h:124
JetTagMonitoring::m_tag_ip2d_c_sj
TH1F_LW * m_tag_ip2d_c_sj
Definition: JetTagMonitoring.h:179
JetTagMonitoring::m_tag_mv_w_eta05_10
TH1F_LW * m_tag_mv_w_eta05_10
Definition: JetTagMonitoring.h:238
JetTagMonitoring::m_tag_mv_w_pT50_100
TH1F_LW * m_tag_mv_w_pT50_100
Definition: JetTagMonitoring.h:227
JetTagMonitoring::m_tag_sv1_llr
TH1F_LW * m_tag_sv1_llr
To monitor jet log likelihood ratio for SV1 tagger.
Definition: JetTagMonitoring.h:210
JetTagMonitoring::m_tracks_etaMax_2D_LS
TH2F_LW * m_tracks_etaMax_2D_LS
Definition: JetTagMonitoring.h:448
JetTagMonitoring::nHitTrtHighE
@ nHitTrtHighE
Definition: JetTagMonitoring.h:416
TH1F_LW::SetBinContent
virtual void SetBinContent(unsigned bin, const double &) override
Definition: TH1F_LW.cxx:267
JetTagMonitoring::m_ElectronPtCut
double m_ElectronPtCut
Definition: JetTagMonitoring.h:141
TH2F_LW::getROOTHist
TH2F * getROOTHist()
Definition: TH2F_LW.cxx:216
JetTagMonitoring::m_tag_mv_w_mu0_30
TH1F_LW * m_tag_mv_w_mu0_30
Definition: JetTagMonitoring.h:462
JetAttributes.h
test_pyathena.pt
pt
Definition: test_pyathena.py:11
JetTagMonitoring::m_tag_ip2d_llr_sj
TH1F_LW * m_tag_ip2d_llr_sj
Definition: JetTagMonitoring.h:182
JetTagMonitoring::m_tag_mv_w_sj_phi21_28
TH1F_LW * m_tag_mv_w_sj_phi21_28
Definition: JetTagMonitoring.h:279
JetTagMonitoring::m_tracks_nHitBLayer_2D_LS
TH2F_LW * m_tracks_nHitBLayer_2D_LS
Definition: JetTagMonitoring.h:449
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
JetTagMonitoring::m_tag_mv_w_sj_eta10_15
TH1F_LW * m_tag_mv_w_sj_eta10_15
Definition: JetTagMonitoring.h:273
JetTagMonitoring::m_mv_tag_60_2D
TH2F_LW * m_mv_tag_60_2D
Definition: JetTagMonitoring.h:404
JetTagMonitoring::m_monGr_LowStat
MonGroup * m_monGr_LowStat
Definition: JetTagMonitoring.h:473
JetTagMonitoring::m_jet_tracks_BLayerHits
TH1F_LW * m_jet_tracks_BLayerHits
To monitor number of b layer hits in a jet.
Definition: JetTagMonitoring.h:346
JetTagMonitoring::m_lumiBlockNum
unsigned int m_lumiBlockNum
Definition: JetTagMonitoring.h:468
JetTagMonitoring::m_tag_sv1_llr_sj
TH1F_LW * m_tag_sv1_llr_sj
Definition: JetTagMonitoring.h:211
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
JetTagMonitoring::m_tag_mv_w_sj_pT20_50
TH1F_LW * m_tag_mv_w_sj_pT20_50
Definition: JetTagMonitoring.h:267
JetTagMonitoring::m_tag_ip3d_b_sj
TH1F_LW * m_tag_ip3d_b_sj
Definition: JetTagMonitoring.h:188
JetTagMonitoring::m_use_trigdectool
bool m_use_trigdectool
Use Analysis::TrigDecisionTool.
Definition: JetTagMonitoring.h:166
ManagedMonitorToolBase::m_dataType
AthenaMonManager::DataType_t m_dataType
Definition: ManagedMonitorToolBase.h:901
JetTagMonitoring::m_tag_mv_w_phi_sum85OP
TH1F_LW * m_tag_mv_w_phi_sum85OP
Definition: JetTagMonitoring.h:247
JetTagMonitoring::m_tag_mv_w_phi28
TH1F_LW * m_tag_mv_w_phi28
Definition: JetTagMonitoring.h:246
TrigDecisionTool.h
JetTagMonitoring::fillJetHistograms
void fillJetHistograms()
Definition: JetTagMonitoring.cxx:1080
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
xAOD::Vertex_v1::position
const Amg::Vector3D & position() const
Returns the 3-pos.
JetTagMonitoring::m_tracks_fitProb_2D_LS
TH2F_LW * m_tracks_fitProb_2D_LS
Definition: JetTagMonitoring.h:457
JetTagMonitoring::m_jtmTrigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_jtmTrigDecTool
Definition: JetTagMonitoring.h:106
JetTagMonitoring::m_isNewLumiBlock
bool m_isNewLumiBlock
Definition: JetTagMonitoring.h:477
JetTagMonitoring::m_global_SiHits
TH1F_LW * m_global_SiHits
To monitor number of pixel+SCT hits in TrackParticle.
Definition: JetTagMonitoring.h:320
JetTagMonitoring::m_tag_mv_w_phi0_07
TH1F_LW * m_tag_mv_w_phi0_07
Definition: JetTagMonitoring.h:242
JetTagMonitoring::m_tracks_deadBLayer_2D
TH2F_LW * m_tracks_deadBLayer_2D
Definition: JetTagMonitoring.h:430
JetTagMonitoring::m_tracks_nHitBLayer_2D
TH2F_LW * m_tracks_nHitBLayer_2D
Definition: JetTagMonitoring.h:429
JetTagMonitoring::m_switch_off
bool m_switch_off
Master kill if no tools found.
Definition: JetTagMonitoring.h:160
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
JetTagMonitoring::m_tag_sv1_b_sj
TH1F_LW * m_tag_sv1_b_sj
Definition: JetTagMonitoring.h:202
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
JetTagMonitoring::m_tag_jetfitter_llr
TH1F_LW * m_tag_jetfitter_llr
To monitor log likelihood ratio for JetFitter.
Definition: JetTagMonitoring.h:213
JetTagMonitoring::m_tag_mv_w_phi_frac60OP
TH1F_LW * m_tag_mv_w_phi_frac60OP
Definition: JetTagMonitoring.h:255
JetTagMonitoring::m_jet_tracks_d0
TH1F_LW * m_jet_tracks_d0
To monitor d0 of tracks in a jet.
Definition: JetTagMonitoring.h:340
JetTagMonitoring::m_tracks_nHitSct_2D_LS
TH2F_LW * m_tracks_nHitSct_2D_LS
Definition: JetTagMonitoring.h:452
read_hist_ntuple.h1
h1
Definition: read_hist_ntuple.py:21
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:40
JetTagMonitoring::m_tag_mv_w_sj_phi_sum77OP
TH1F_LW * m_tag_mv_w_sj_phi_sum77OP
Definition: JetTagMonitoring.h:282
JetTagMonitoring::m_tag_mv_w_sj_phi_frac77OP
TH1F_LW * m_tag_mv_w_sj_phi_frac77OP
Definition: JetTagMonitoring.h:287
JetTagMonitoring::m_tracks_nHitSi_2D_LS
TH2F_LW * m_tracks_nHitSi_2D_LS
Definition: JetTagMonitoring.h:453
JetTagMonitoring::m_track_selector_eff
TH2F_LW * m_track_selector_eff
2D map of track selector efficiency.
Definition: JetTagMonitoring.h:373
JetTagMonitoring::m_jet_tracks_pt
TH1F_LW * m_jet_tracks_pt
To monitor Pt of tracks in a jet.
Definition: JetTagMonitoring.h:334
xAOD::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the first pixel layer, i.e.
Definition: TrackingPrimitives.h:231
JetTagMonitoring::m_tag_mv_w_sj
TH1F_LW * m_tag_mv_w_sj
Definition: JetTagMonitoring.h:265
JetTagMonitoring::m_priVtx_trks
TH1F_LW * m_priVtx_trks
Definition: JetTagMonitoring.h:370
xAOD::TrackParticle_v1::d0
float d0() const
Returns the parameter.
JetTagMonitoring::m_jet_2D_bad
TH2F_LW * m_jet_2D_bad
Definition: JetTagMonitoring.h:398
JetTagMonitoring::m_tag_ip2d_b
TH1F_LW * m_tag_ip2d_b
To monitor jet likelihood value if coming from b decay for IP2D tagger.
Definition: JetTagMonitoring.h:172
JetTagMonitoring::m_tag_mv_w_pT50_100_LS
TH1F_LW * m_tag_mv_w_pT50_100_LS
Definition: JetTagMonitoring.h:233
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
JetTagMonitoring::m_jet_tracks_d0_LS
TH1F_LW * m_jet_tracks_d0_LS
Definition: JetTagMonitoring.h:341
LArEventBitInfo.h
JetTagMonitoring::passKinematicCuts
bool passKinematicCuts(const xAOD::Jet *jet)
Definition: JetTagMonitoring.cxx:797
JetTagMonitoring::m_tag_mv_w_sj_phi_sum70OP
TH1F_LW * m_tag_mv_w_sj_phi_sum70OP
Definition: JetTagMonitoring.h:283
JetTagMonitoring::m_tag_mv_w_eta15_20
TH1F_LW * m_tag_mv_w_eta15_20
Definition: JetTagMonitoring.h:240
JetTagMonitoring::m_tag_mv_w_sj_phi_sum85OP
TH1F_LW * m_tag_mv_w_sj_phi_sum85OP
Definition: JetTagMonitoring.h:281
xAOD::EventInfo_v1::Error
@ Error
The sub-detector issued an error.
Definition: EventInfo_v1.h:349
JetTagMonitoring::m_tag_mv_w_sj_eta05_10
TH1F_LW * m_tag_mv_w_sj_eta05_10
Definition: JetTagMonitoring.h:272
AthenaMonManager::environment
static Environment_t environment()
Returns the running environment of the monitoring application to help ManagedMonitorToolBase objects ...
Definition: AthenaMonManager.cxx:321
JetTagMonitoring::m_tag_mv_w_sj_eta_frac70OP
TH1F_LW * m_tag_mv_w_sj_eta_frac70OP
Definition: JetTagMonitoring.h:297
JetTagMonitoring::m_tag_mv_w_pT20_50_LS
TH1F_LW * m_tag_mv_w_pT20_50_LS
Definition: JetTagMonitoring.h:232
JetTagMonitoring::m_tag_mv_w_eta_sum60OP
TH1F_LW * m_tag_mv_w_eta_sum60OP
Definition: JetTagMonitoring.h:259
JetTagMonitoring::m_tag_mv_w_eta_sum85OP
TH1F_LW * m_tag_mv_w_eta_sum85OP
Definition: JetTagMonitoring.h:256
JetTagMonitoring::m_cutflow
TH1F_LW * m_cutflow
Definition: JetTagMonitoring.h:366
LWHist::GetXaxis
LWHistAxis * GetXaxis()
Definition: LWHist.cxx:309
JetTagMonitoring::sigd0Max
@ sigd0Max
Definition: JetTagMonitoring.h:415
JetTagMonitoring::m_global_SCTHits
TH1F_LW * m_global_SCTHits
To monitor number of SCT hits in TrackParticle.
Definition: JetTagMonitoring.h:318
JetTagMonitoring::m_tag_sv1_c_sj
TH1F_LW * m_tag_sv1_c_sj
Definition: JetTagMonitoring.h:208
JetTagMonitoring::m_mv_77_weight_cut
double m_mv_77_weight_cut
Definition: JetTagMonitoring.h:136
JetTagMonitoring::m_ElectronTrigger_201X
std::string m_ElectronTrigger_201X
Definition: JetTagMonitoring.h:156
ManagedMonitorToolBase::lbInteractionsPerCrossing
virtual float lbInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Instantaneous number of interactions, i.e.
Definition: ManagedMonitorToolBase.cxx:1940
JetTagMonitoring::m_trk_n
unsigned int m_trk_n
Definition: JetTagMonitoring.h:132
JetTagMonitoring::m_tracks_sigz0Max_2D_LS
TH2F_LW * m_tracks_sigz0Max_2D_LS
Definition: JetTagMonitoring.h:447
JetTagMonitoring::m_tag_mv_w_pT200
TH1F_LW * m_tag_mv_w_pT200
Definition: JetTagMonitoring.h:229
JetTagMonitoring::m_tag_ip2d_u_sj
TH1F_LW * m_tag_ip2d_u_sj
Definition: JetTagMonitoring.h:176
JetTagMonitoring::m_tag_mv_w_eta_frac60OP
TH1F_LW * m_tag_mv_w_eta_frac60OP
Definition: JetTagMonitoring.h:264
JetTagMonitoring::m_tag_sv1_u
TH1F_LW * m_tag_sv1_u
To monitor jet likelihood value if coming from u decay for SV1 tagger.
Definition: JetTagMonitoring.h:204
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:138
JetTagMonitoring::m_tag_mv_w_phi_sum70OP
TH1F_LW * m_tag_mv_w_phi_sum70OP
Definition: JetTagMonitoring.h:249
JetTagMonitoring::m_mv_60_weight_cut
double m_mv_60_weight_cut
Definition: JetTagMonitoring.h:134
JetTagMonitoring::m_jet_pt_top_tagged
TH1F_LW * m_jet_pt_top_tagged
Definition: JetTagMonitoring.h:385
JetTagMonitoring::m_jet_2D_all
TH2F_LW * m_jet_2D_all
2D map of jets at various cuts.
Definition: JetTagMonitoring.h:391
JetTagMonitoring::m_tag_mv_w_phi07_14
TH1F_LW * m_tag_mv_w_phi07_14
Definition: JetTagMonitoring.h:243
xAOD::JetAttribute::HECQuality
@ HECQuality
Definition: JetAttributes.h:80
JetTagMonitoring::m_tag_mv_w_eta_sum70OP
TH1F_LW * m_tag_mv_w_eta_sum70OP
Definition: JetTagMonitoring.h:258
AthenaMonManager::tier0ESD
@ tier0ESD
Definition: AthenaMonManager.h:49
JetTagMonitoring::m_tag_jetfitter_llr_sj
TH1F_LW * m_tag_jetfitter_llr_sj
Definition: JetTagMonitoring.h:214
TauGNNUtils::Variables::Track::nSiHits
bool nSiHits(const xAOD::TauJet &, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:691
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
TH1F_LW
Definition: TH1F_LW.h:23
JetTagMonitoring::m_tracks_nHitPix_2D
TH2F_LW * m_tracks_nHitPix_2D
Definition: JetTagMonitoring.h:431
JetTagMonitoring::m_jet_tracks_n
TH1F_LW * m_jet_tracks_n
To monitor number of tracks in a jet.
Definition: JetTagMonitoring.h:332
JetTagMonitoring::m_tag_mv_w_sj_phi_sumAll
TH1F_LW * m_tag_mv_w_sj_phi_sumAll
Definition: JetTagMonitoring.h:285
JetTagMonitoring::m_global_BLayerHits
TH1F_LW * m_global_BLayerHits
To monitor number of b layer hits in TrackParticle.
Definition: JetTagMonitoring.h:314
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
JetTagMonitoring::m_jet_2D_kinematic
TH2F_LW * m_jet_2D_kinematic
Definition: JetTagMonitoring.h:393
JetTagMonitoring::m_doLumiBlock
bool m_doLumiBlock
Definition: JetTagMonitoring.h:478
JetTagMonitoring::m_tag_ip2d_llr
TH1F_LW * m_tag_ip2d_llr
To monitor jet log likelihood ratio for IP2D tagger.
Definition: JetTagMonitoring.h:181
JetTagMonitoring::m_tag_mv_w_eta10_15
TH1F_LW * m_tag_mv_w_eta10_15
Definition: JetTagMonitoring.h:239
JetTagMonitoring::m_tracks_sigd0Max_2D
TH2F_LW * m_tracks_sigd0Max_2D
Definition: JetTagMonitoring.h:426
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
JetTagMonitoring::m_muonName
SG::ReadHandleKey< xAOD::MuonContainer > m_muonName
String to retrieve MuonContainer from StoreGate.
Definition: JetTagMonitoring.h:121
JetTagMonitoring::m_tag_mv_w_phi_sumAll
TH1F_LW * m_tag_mv_w_phi_sumAll
Definition: JetTagMonitoring.h:251
JetTagMonitoring::m_tag_mv_w_phi_frac85OP
TH1F_LW * m_tag_mv_w_phi_frac85OP
Definition: JetTagMonitoring.h:252
JetTagMonitoring::passJVTCuts
bool passJVTCuts(const xAOD::Jet *jet)
Definition: JetTagMonitoring.cxx:1624
JetTagMonitoring::m_sv1ip3d_tag_neg_rate_2D
TH2F_LW * m_sv1ip3d_tag_neg_rate_2D
Definition: JetTagMonitoring.h:402
JetTagMonitoring::m_tag_mv_w_sj_pT10_20
TH1F_LW * m_tag_mv_w_sj_pT10_20
Definition: JetTagMonitoring.h:266
JetTagMonitoring::m_tag_mv_w_sj_eta0_05
TH1F_LW * m_tag_mv_w_sj_eta0_05
Definition: JetTagMonitoring.h:271
JetTagMonitoring::m_jetName
SG::ReadHandleKey< xAOD::JetContainer > m_jetName
String to retrieve JetContainer from StoreGate.
Definition: JetTagMonitoring.h:113
lumiFormat.i
int i
Definition: lumiFormat.py:92
JetTagMonitoring::m_tag_ip2d_u
TH1F_LW * m_tag_ip2d_u
To monitor jet likelihood value if coming from u decay for IP2D tagger.
Definition: JetTagMonitoring.h:175
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
JetTagMonitoring::m_jet_n
TH1F_LW * m_jet_n
To monitor number of Jets.
Definition: JetTagMonitoring.h:300
JetTagMonitoring::m_MuonTopoEtCone20Cut
double m_MuonTopoEtCone20Cut
Definition: JetTagMonitoring.h:147
xAOD::JetAttribute::EMFrac
@ EMFrac
Definition: JetAttributes.h:112
JetTagMonitoring::m_ElectronPtVarCone20Cut
double m_ElectronPtVarCone20Cut
Definition: JetTagMonitoring.h:146
JetTagMonitoring::m_tag_sv1_c
TH1F_LW * m_tag_sv1_c
To monitor jet likelihood value if coming from c decay for SV1 tagger.
Definition: JetTagMonitoring.h:207
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
JetTagMonitoring::~JetTagMonitoring
~JetTagMonitoring()
Definition: JetTagMonitoring.cxx:94
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthenaMonManager::online
@ online
Definition: AthenaMonManager.h:49
JetTagMonitoring::m_tag_mv_w_sj_eta15_20
TH1F_LW * m_tag_mv_w_sj_eta15_20
Definition: JetTagMonitoring.h:274
JetTagMonitoring::m_tag_ip3d_c_sj
TH1F_LW * m_tag_ip3d_c_sj
Definition: JetTagMonitoring.h:194
JetTagMonitoring::m_mv_85_weight_cut
double m_mv_85_weight_cut
Definition: JetTagMonitoring.h:137
JetTagMonitoring::fillSuspectJetHistos
void fillSuspectJetHistos(const xAOD::Jet *jet)
Definition: JetTagMonitoring.cxx:1553
JetTagMonitoring::m_tracks_passedCuts_2D
TH2F_LW * m_tracks_passedCuts_2D
Definition: JetTagMonitoring.h:440
JetTagMonitoring::m_tracks_etaMax_2D
TH2F_LW * m_tracks_etaMax_2D
Definition: JetTagMonitoring.h:428
JetTagMonitoring::m_track_selector_all_LS
TH2F_LW * m_track_selector_all_LS
Definition: JetTagMonitoring.h:377
JetTagMonitoring::m_jet_2D_quality
TH2F_LW * m_jet_2D_quality
Definition: JetTagMonitoring.h:396
ManagedMonitorToolBase::newLowStatIntervalFlag
bool newLowStatIntervalFlag() const
Flag functions allowing clients to determine when to book new and process old histograms; values are ...
Definition: ManagedMonitorToolBase.h:849
JetTagMonitoring::m_tag_mv_w_sj_eta_sumAll
TH1F_LW * m_tag_mv_w_sj_eta_sumAll
Definition: JetTagMonitoring.h:294
JetTagMonitoring::m_track_selector_all
TH2F_LW * m_track_selector_all
Definition: JetTagMonitoring.h:376
JetTagMonitoring::m_tag_ip2d_c
TH1F_LW * m_tag_ip2d_c
To monitor jet likelihood value if coming from c decay for IP2D tagger.
Definition: JetTagMonitoring.h:178
JetTagMonitoring::m_mv_algorithmName
std::string m_mv_algorithmName
Definition: JetTagMonitoring.h:138
JetTagMonitoring::m_tag_ip2d_n_sj
TH1F_LW * m_tag_ip2d_n_sj
Definition: JetTagMonitoring.h:170
xAOD::JetAttribute::SumPtTrkPt1000
@ SumPtTrkPt1000
Definition: JetAttributes.h:107
JetTagMonitoring::m_ElectronTrigger_2016
std::string m_ElectronTrigger_2016
Definition: JetTagMonitoring.h:150
JetTagMonitoring::m_trackParticleName
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackParticleName
String to retrieve TrackParticleContainer from StoreGate.
Definition: JetTagMonitoring.h:115
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
JetTagMonitoring::m_global_PixelHits
TH1F_LW * m_global_PixelHits
To monitor number of pixel hits in TrackParticle.
Definition: JetTagMonitoring.h:316
xAOD::JetAttribute::Timing
@ Timing
Definition: JetAttributes.h:90
test_pyathena.parent
parent
Definition: test_pyathena.py:15
VxSecVertexInfo.h
JetTagMonitoring::m_tag_mv_w_phi_sum77OP
TH1F_LW * m_tag_mv_w_phi_sum77OP
Definition: JetTagMonitoring.h:248
JetTagMonitoring::m_global_yPrimVtx
TH1F_LW * m_global_yPrimVtx
To monitor y of primary vertex.
Definition: JetTagMonitoring.h:309
JetTagMonitoring::initialize
virtual StatusCode initialize()
Definition: JetTagMonitoring.cxx:134
JetTagMonitoring::m_jet_tracks_eta
TH1F_LW * m_jet_tracks_eta
To monitor eta of tracks in a jet.
Definition: JetTagMonitoring.h:336
JetTagMonitoring::m_MuonPtVarCone30Cut
double m_MuonPtVarCone30Cut
Definition: JetTagMonitoring.h:149
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
JetTagMonitoring::m_tag_mv_w_sj_eta_frac85OP
TH1F_LW * m_tag_mv_w_sj_eta_frac85OP
Definition: JetTagMonitoring.h:295
JetTagMonitoring::deadBLayer
@ deadBLayer
Definition: JetTagMonitoring.h:416
JetTagMonitoring::m_tag_mv_w_pT200_LS
TH1F_LW * m_tag_mv_w_pT200_LS
Definition: JetTagMonitoring.h:235
run
Definition: run.py:1
JetTagMonitoring::m_tag_mv_w_pT100_200_LS
TH1F_LW * m_tag_mv_w_pT100_200_LS
Definition: JetTagMonitoring.h:234
JetTagMonitoring::m_tag_mv_w_sj_phi0_07
TH1F_LW * m_tag_mv_w_sj_phi0_07
Definition: JetTagMonitoring.h:276
xAOD::Vertex_v1::z
float z() const
Returns the z position.
JetTagMonitoring::m_tag_ip3d_u
TH1F_LW * m_tag_ip3d_u
To monitor jet likelihood value if coming from u decay for IP3D tagger.
Definition: JetTagMonitoring.h:190
JetTagMonitoring::m_tracks_pTMin_2D_LS
TH2F_LW * m_tracks_pTMin_2D_LS
Definition: JetTagMonitoring.h:443
JetTagMonitoring::m_jet_phi
TH1F_LW * m_jet_phi
To monitor phi of the reconstructed jet.
Definition: JetTagMonitoring.h:327
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
JetTagMonitoring::m_jet_tracks_phi
TH1F_LW * m_jet_tracks_phi
To monitor phi of tracks in a jet.
Definition: JetTagMonitoring.h:338
JetTagMonitoring::m_MuonPtCut
double m_MuonPtCut
Definition: JetTagMonitoring.h:139
xAOD::BTagging_v1
Definition: BTagging_v1.h:39
JetTagMonitoring::fillTrackInJetHistograms
void fillTrackInJetHistograms(const xAOD::Jet *jet)
Definition: JetTagMonitoring.cxx:1208
JetTagMonitoring::pTMin
@ pTMin
Definition: JetTagMonitoring.h:415
JetTagMonitoring::m_tag_mv_w_phi_frac77OP
TH1F_LW * m_tag_mv_w_phi_frac77OP
Definition: JetTagMonitoring.h:253
JetTagMonitoring::m_jet_tracks_SCTHits
TH1F_LW * m_jet_tracks_SCTHits
To monitor number of SCT hits in a jet.
Definition: JetTagMonitoring.h:350
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:902
ManagedMonitorToolBase::MonGroup::regHist
StatusCode regHist(TH1 *h)
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition: ManagedMonitorToolBase.cxx:195
JetTagMonitoring::m_tag_ip3d_n_sj
TH1F_LW * m_tag_ip3d_n_sj
Definition: JetTagMonitoring.h:185
JetTagMonitoring::fillBadJetHistos
void fillBadJetHistos(const xAOD::Jet *jet)
Definition: JetTagMonitoring.cxx:1616
JetTagMonitoring::m_tag_mv_w_LS
TH1F_LW * m_tag_mv_w_LS
Definition: JetTagMonitoring.h:230
JetTagMonitoring::m_tag_mv_w_sj_phi_frac70OP
TH1F_LW * m_tag_mv_w_sj_phi_frac70OP
Definition: JetTagMonitoring.h:288
LinkToTrackParticleBase.h
JetTagMonitoring::m_jet_pt_top_eff
TH1F_LW * m_jet_pt_top_eff
Definition: JetTagMonitoring.h:388
JetTagMonitoring::m_tag_mv_w_sj_eta_sum70OP
TH1F_LW * m_tag_mv_w_sj_eta_sum70OP
Definition: JetTagMonitoring.h:292
JetTagMonitoring::m_tracks_fitChi2OnNdfMax_2D
TH2F_LW * m_tracks_fitChi2OnNdfMax_2D
Definition: JetTagMonitoring.h:438
JetTagMonitoring::m_trk_d0_min_cut
double m_trk_d0_min_cut
Definition: JetTagMonitoring.h:127
JetTagMonitoring::m_tag_ip2d_n
TH1F_LW * m_tag_ip2d_n
To monitor number of tracks used to evaluate IP2D weight.
Definition: JetTagMonitoring.h:169
JetTagMonitoring::m_runNumber
unsigned int m_runNumber
Definition: JetTagMonitoring.h:470
JetTagMonitoring::JetTagMonitoring
JetTagMonitoring(const std::string &type, const std::string &name, const IInterface *parent)
Definition: JetTagMonitoring.cxx:40
JetTagMonitoring::m_electronName
SG::ReadHandleKey< xAOD::ElectronContainer > m_electronName
String to retrieve ElectronContainer from StoreGate.
Definition: JetTagMonitoring.h:119
JetTagMonitoring::m_tag_sv0_sig3d
TH1F_LW * m_tag_sv0_sig3d
To monitor jet 3D significance of SV0 tagger.
Definition: JetTagMonitoring.h:199
JetTagMonitoring::badJet
@ badJet
Definition: JetTagMonitoring.h:82
TH1F_LW::getROOTHistBase
virtual TH1 * getROOTHistBase() override
Definition: TH1F_LW.cxx:144
JetTagMonitoring::m_tracks_nHitTrtHighE_2D_LS
TH2F_LW * m_tracks_nHitTrtHighE_2D_LS
Definition: JetTagMonitoring.h:455
JetTagMonitoring::m_tag_mv_w_sj_eta20_25
TH1F_LW * m_tag_mv_w_sj_eta20_25
Definition: JetTagMonitoring.h:275
JetTagMonitoring::m_tracks_z0Max_2D_LS
TH2F_LW * m_tracks_z0Max_2D_LS
Definition: JetTagMonitoring.h:445
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
JetTagMonitoring::m_tag_ip3d_u_sj
TH1F_LW * m_tag_ip3d_u_sj
Definition: JetTagMonitoring.h:191
JetTagMonitoring::goodJet
@ goodJet
Definition: JetTagMonitoring.h:82
TH2F_LW::create
static TH2F_LW * create(const char *name, const char *title, unsigned nbinsx, const double &xmin, const double &xmax, unsigned nbinsy, const double &ymin, const double &ymax)
Definition: TH2F_LW.cxx:33
LWHist::LWHistAxis::SetBinLabel
void SetBinLabel(unsigned bin, const char *label)
Definition: LWHist.cxx:411
JetTagMonitoring::m_tag_mv_w_pT20_50
TH1F_LW * m_tag_mv_w_pT20_50
Definition: JetTagMonitoring.h:226
JetTagMonitoring::m_tag_mv_w_sj_pT50_100
TH1F_LW * m_tag_mv_w_sj_pT50_100
Definition: JetTagMonitoring.h:268
JetTagMonitoring::m_tracks_z0Max_2D
TH2F_LW * m_tracks_z0Max_2D
Definition: JetTagMonitoring.h:425
JetTagMonitoring::m_n_iso_el
TH1F_LW * m_n_iso_el
Definition: JetTagMonitoring.h:362
JetTagMonitoring::m_global_xPrimVtx
TH1F_LW * m_global_xPrimVtx
To monitor x of primary vertex.
Definition: JetTagMonitoring.h:307
JetTagMonitoring::m_tag_jfcnn_llr_sj
TH1F_LW * m_tag_jfcnn_llr_sj
Definition: JetTagMonitoring.h:217
TauGNNUtils::Variables::Track::nSCTHits
bool nSCTHits(const xAOD::TauJet &, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:549
JetTagMonitoring::m_tag_ip3d_llr_sj
TH1F_LW * m_tag_ip3d_llr_sj
Definition: JetTagMonitoring.h:197
JetTagMonitoring::m_tag_mv_w_sj_phi_sum60OP
TH1F_LW * m_tag_mv_w_sj_phi_sum60OP
Definition: JetTagMonitoring.h:284
JetTagMonitoring::m_tag_mv_w_sj_eta_sum85OP
TH1F_LW * m_tag_mv_w_sj_eta_sum85OP
Definition: JetTagMonitoring.h:290
JetTagMonitoring::m_priVtx
const xAOD::Vertex * m_priVtx
Definition: JetTagMonitoring.h:110
JetTagMonitoring::m_tag_mv_w_pT10_20
TH1F_LW * m_tag_mv_w_pT10_20
Definition: JetTagMonitoring.h:225
JetTagMonitoring::m_tracks_fitProb_2D
TH2F_LW * m_tracks_fitProb_2D
Definition: JetTagMonitoring.h:437
JetTagMonitoring::m_tag_mv_w_phi_sum60OP
TH1F_LW * m_tag_mv_w_phi_sum60OP
Definition: JetTagMonitoring.h:250
JetTagMonitoring::m_do_cuts
bool m_do_cuts
DQ cuts switcher.
Definition: JetTagMonitoring.h:126
ManagedMonitorToolBase::lowStat
@ lowStat
Definition: ManagedMonitorToolBase.h:115
JetTagMonitoring::m_track_selector_suspect
TH2F_LW * m_track_selector_suspect
Definition: JetTagMonitoring.h:375
JetTagMonitoring::m_jet_top
TH1F_LW * m_jet_top
top histograms
Definition: JetTagMonitoring.h:380
JetTagMonitoring::m_MuonPtVarCone20Cut
double m_MuonPtVarCone20Cut
Definition: JetTagMonitoring.h:148
JetTagMonitoring::nHitTrt
@ nHitTrt
Definition: JetTagMonitoring.h:416
JetTagMonitoring::m_ElectronTopoEtCone20Cut
double m_ElectronTopoEtCone20Cut
Definition: JetTagMonitoring.h:145
JetTagMonitoring::m_tag_mv_w_eta_frac85OP
TH1F_LW * m_tag_mv_w_eta_frac85OP
Definition: JetTagMonitoring.h:261
JetTagMonitoring::m_JetTrigger_2017
std::string m_JetTrigger_2017
Definition: JetTagMonitoring.h:155
JetTagMonitoring::m_mv_70_weight_cut
double m_mv_70_weight_cut
Definition: JetTagMonitoring.h:135
xAOD::BTaggingUtilities::getBTagging
const BTagging * getBTagging(const SG::AuxElement &part)
Access the default xAOD::BTagging object associated to an object.
Definition: BTaggingUtilities.cxx:37
JetTagMonitoring::m_jet_2D_jvt
TH2F_LW * m_jet_2D_jvt
Definition: JetTagMonitoring.h:394
JetTagMonitoring::m_tag_mv_w_phi_frac70OP
TH1F_LW * m_tag_mv_w_phi_frac70OP
Definition: JetTagMonitoring.h:254
CheckAppliedSFs.pu
pu
Definition: CheckAppliedSFs.py:311
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
JetTagMonitoring::fillBadTrackBits
void fillBadTrackBits(const std::bitset< 17 > &failedCuts, double eta, double phi)
Definition: JetTagMonitoring.cxx:1396
JetTagMonitoring::m_trackSelectorTool
ToolHandle< Analysis::TrackSelector > m_trackSelectorTool
Definition: JetTagMonitoring.h:104
JetTagMonitoring::m_MuonTrigger_2016
std::string m_MuonTrigger_2016
Definition: JetTagMonitoring.h:151
JetTagMonitoring::m_tracks_all_2D_LS
TH2F_LW * m_tracks_all_2D_LS
Definition: JetTagMonitoring.h:442
JetTagMonitoring::m_tracks_deadBLayer_2D_LS
TH2F_LW * m_tracks_deadBLayer_2D_LS
Definition: JetTagMonitoring.h:450
JetTagMonitoring::z0Max
@ z0Max
Definition: JetTagMonitoring.h:415
VxSecVKalVertexInfo.h
JetTagMonitoring::fillGoodJetHistos
void fillGoodJetHistos(const xAOD::Jet *jet)
Definition: JetTagMonitoring.cxx:1438
JetTagMonitoring::m_jet_tracks_PixelHits
TH1F_LW * m_jet_tracks_PixelHits
To monitor number of pixel hits in a jet.
Definition: JetTagMonitoring.h:348
JetTagMonitoring::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: JetTagMonitoring.cxx:548
JetTagMonitoring::m_jet_tracks_z0_LS
TH1F_LW * m_jet_tracks_z0_LS
Definition: JetTagMonitoring.h:344
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ManagedMonitorToolBase::endOfRunFlag
bool endOfRunFlag() const
Definition: ManagedMonitorToolBase.h:859
JetTagMonitoring::isTopEvent
bool isTopEvent()
Definition: JetTagMonitoring.cxx:886
JetTagMonitoring::m_tag_ip3d_llr
TH1F_LW * m_tag_ip3d_llr
To monitor jet log likelihood ratio for IP3D tagger.
Definition: JetTagMonitoring.h:196
JetTagMonitoring::Jet_t
Jet_t
Definition: JetTagMonitoring.h:82
JetTagMonitoring::m_monGr_shift
MonGroup * m_monGr_shift
Definition: JetTagMonitoring.h:472
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TH1
Definition: rootspy.cxx:268
JetTagMonitoring::passJetQualityCuts
bool passJetQualityCuts(const xAOD::Jet *jet)
Definition: JetTagMonitoring.cxx:1515
DEBUG
#define DEBUG
Definition: page_access.h:11
JetTagMonitoring::m_trk_d0_max_cut
double m_trk_d0_max_cut
Definition: JetTagMonitoring.h:128
JetTagMonitoring::m_ElectronTrigger_2017
std::string m_ElectronTrigger_2017
Definition: JetTagMonitoring.h:153
JetTagMonitoring::m_jet_2D_good
TH2F_LW * m_jet_2D_good
Definition: JetTagMonitoring.h:392
xAOD::Vertex_v1::y
float y() const
Returns the y position.
JetTagMonitoring::m_tag_mv_w_sj_pT200
TH1F_LW * m_tag_mv_w_sj_pT200
Definition: JetTagMonitoring.h:270
JetTagMonitoring::nHitSi
@ nHitSi
Definition: JetTagMonitoring.h:416
JetTagMonitoring::m_ElectronEtaCut
double m_ElectronEtaCut
Definition: JetTagMonitoring.h:142
JetTagMonitoring::m_tracks_nHitTrt_2D_LS
TH2F_LW * m_tracks_nHitTrt_2D_LS
Definition: JetTagMonitoring.h:454
JetTagMonitoring::fitChi2
@ fitChi2
Definition: JetTagMonitoring.h:417
JetTagMonitoring::etaMax
@ etaMax
Definition: JetTagMonitoring.h:415
JetTagMonitoring::m_jet_2D_suspect
TH2F_LW * m_jet_2D_suspect
Definition: JetTagMonitoring.h:397
JetTagMonitoring::fillBtagHistograms
void fillBtagHistograms(const xAOD::Jet *jet, bool fill_top_histos)
Definition: JetTagMonitoring.cxx:1251
JetTagMonitoring::m_jet_2D_kinematic_LS
TH2F_LW * m_jet_2D_kinematic_LS
Definition: JetTagMonitoring.h:395
JetTagMonitoring::m_MuonTrigger_2017
std::string m_MuonTrigger_2017
Definition: JetTagMonitoring.h:154
JetTagMonitoring::m_tag_mv_w_sj_eta_sum60OP
TH1F_LW * m_tag_mv_w_sj_eta_sum60OP
Definition: JetTagMonitoring.h:293
ITrackToVertexIPEstimator.h
JetTagMonitoring::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: JetTagMonitoring.h:123
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
JetTagMonitoring::m_tag_mv_w_sj_eta_frac77OP
TH1F_LW * m_tag_mv_w_sj_eta_frac77OP
Definition: JetTagMonitoring.h:296
JetTagMonitoring::m_tag_mv_w_sj_phi28
TH1F_LW * m_tag_mv_w_sj_phi28
Definition: JetTagMonitoring.h:280
xAOD::JetAttribute::HECFrac
@ HECFrac
Definition: JetAttributes.h:113
defineDB.jets
list jets
Definition: JetTagCalibration/share/defineDB.py:24
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
JetTagMonitoring::m_jet_pt_top
TH1F_LW * m_jet_pt_top
Definition: JetTagMonitoring.h:381
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
JetTagMonitoring::m_jet_eta_cut
double m_jet_eta_cut
Definition: JetTagMonitoring.h:131
JetTagMonitoring::m_trackParticle_n
TH1F_LW * m_trackParticle_n
To monitor number of TrackParticles.
Definition: JetTagMonitoring.h:302
JetTagMonitoring::m_tracks_d0Max_2D_LS
TH2F_LW * m_tracks_d0Max_2D_LS
Definition: JetTagMonitoring.h:444
JetTagMonitoring::m_JetTrigger_2016
std::string m_JetTrigger_2016
Definition: JetTagMonitoring.h:152
JetTagMonitoring::m_MuonEtaCut
double m_MuonEtaCut
Definition: JetTagMonitoring.h:140
JetTagMonitoring::m_tracks_nHitTrt_2D
TH2F_LW * m_tracks_nHitTrt_2D
Definition: JetTagMonitoring.h:434
JetTagMonitoring::bookHistograms
virtual StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition: JetTagMonitoring.cxx:177
JetTagMonitoring::nHitSct
@ nHitSct
Definition: JetTagMonitoring.h:416
JetTagMonitoring::m_tag_mv_w_sj_phi14_21
TH1F_LW * m_tag_mv_w_sj_phi14_21
Definition: JetTagMonitoring.h:278
JetTagMonitoring::m_tag_mv_w
TH1F_LW * m_tag_mv_w
To monitor likelihood weight based on Mv tagger.
Definition: JetTagMonitoring.h:224
ManagedMonitorToolBase::newLumiBlockFlag
bool newLumiBlockFlag() const
Definition: ManagedMonitorToolBase.h:853
JetTagMonitoring::m_tracks_sigz0Max_2D
TH2F_LW * m_tracks_sigz0Max_2D
Definition: JetTagMonitoring.h:427
xAOD::JetAttribute::GhostTrack
@ GhostTrack
Definition: JetAttributes.h:252
JetTagMonitoring::m_tag_sv1ip3d_w_sj
TH1F_LW * m_tag_sv1ip3d_w_sj
Definition: JetTagMonitoring.h:221
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
JetTagMonitoring::m_tracks_fitChi2_2D
TH2F_LW * m_tracks_fitChi2_2D
Definition: JetTagMonitoring.h:436
JetTagMonitoring::m_tag_mv_w_eta_frac77OP
TH1F_LW * m_tag_mv_w_eta_frac77OP
Definition: JetTagMonitoring.h:262
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
JetTagMonitoring::m_use_trackselector
bool m_use_trackselector
Use Analysis::TrackSelector.
Definition: JetTagMonitoring.h:163
JetTagMonitoring.h
JetTagMonitoring::m_tag_mv_w_eta20_25
TH1F_LW * m_tag_mv_w_eta20_25
Definition: JetTagMonitoring.h:241
JetTagMonitoring::m_doStatus
bool m_doStatus
Definition: JetTagMonitoring.h:480
JetTagMonitoring::d0Max
@ d0Max
Definition: JetTagMonitoring.h:415
JetTagMonitoring::nHitBLayer
@ nHitBLayer
Definition: JetTagMonitoring.h:416
LWHist.h
JetTagMonitoring::m_tag_mv_w_phi21_28
TH1F_LW * m_tag_mv_w_phi21_28
Definition: JetTagMonitoring.h:245
JetTagMonitoring::m_tag_mv_w_sj_pT100_200
TH1F_LW * m_tag_mv_w_sj_pT100_200
Definition: JetTagMonitoring.h:269
JetTagMonitoring::m_tag_mv_w_phi14_21
TH1F_LW * m_tag_mv_w_phi14_21
Definition: JetTagMonitoring.h:244
xAOD::EventInfo_v1::Core
@ Core
Core flags describing the event.
Definition: EventInfo_v1.h:339
python.SystemOfUnits.pc
float pc
Definition: SystemOfUnits.py:99
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
HI::SubCalo::Lists::Tile
constexpr std::initializer_list< int > Tile
Definition: HIEventDefs.h:70
JetTagMonitoring::m_tag_mv_w_pT100_200
TH1F_LW * m_tag_mv_w_pT100_200
Definition: JetTagMonitoring.h:228
JetTagMonitoring::m_tag_mv_w_eta_sumAll
TH1F_LW * m_tag_mv_w_eta_sumAll
Definition: JetTagMonitoring.h:260
xAOD::JetAttribute::NegativeE
@ NegativeE
Definition: JetAttributes.h:84
JetTagMonitoring::m_tracks_nHitSct_2D
TH2F_LW * m_tracks_nHitSct_2D
Definition: JetTagMonitoring.h:432
JetTagMonitoring::m_jet_tracks_z0
TH1F_LW * m_jet_tracks_z0
To monitor z0 of tracks in a jet.
Definition: JetTagMonitoring.h:343
JetTagMonitoring::m_tracks_fitChi2OnNdfMax_2D_LS
TH2F_LW * m_tracks_fitChi2OnNdfMax_2D_LS
Definition: JetTagMonitoring.h:458
JetTagMonitoring::m_tag_mv_w_mu50_70
TH1F_LW * m_tag_mv_w_mu50_70
Definition: JetTagMonitoring.h:464
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
JetTagMonitoring::m_trigPassed
TH1F_LW * m_trigPassed
Definition: JetTagMonitoring.h:365
xAOD::EgammaParameters::AuthorElectron
const uint16_t AuthorElectron
Object Reconstructed by standard cluster-based algorithm.
Definition: EgammaDefs.h:24
JetTagMonitoring::m_sv1ip3d_tag_pos_rate_2D
TH2F_LW * m_sv1ip3d_tag_pos_rate_2D
2D map of tag rates.
Definition: JetTagMonitoring.h:401
JetTagMonitoring::m_tracks_nHitSi_2D
TH2F_LW * m_tracks_nHitSi_2D
Definition: JetTagMonitoring.h:433
ManagedMonitorToolBase::newRunFlag
bool newRunFlag() const
Definition: ManagedMonitorToolBase.h:854
JetTagMonitoring::m_tracks_all_2D
TH2F_LW * m_tracks_all_2D
2D map of TrackSelectorTool cuts
Definition: JetTagMonitoring.h:422
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
JetTagMonitoring::m_MuonTrigger_201X
std::string m_MuonTrigger_201X
Definition: JetTagMonitoring.h:157
JetTagMonitoring::m_tag_ip3d_b
TH1F_LW * m_tag_ip3d_b
To monitor jet likelihood value if coming from b decay for IP3D tagger.
Definition: JetTagMonitoring.h:187
JetTagMonitoring::m_jet_top_tagged
TH1F_LW * m_jet_top_tagged
Definition: JetTagMonitoring.h:384
JetTagMonitoring::m_tag_mv_w_mu30_50
TH1F_LW * m_tag_mv_w_mu30_50
Definition: JetTagMonitoring.h:463
JetTagMonitoring::m_tag_ip3d_n
TH1F_LW * m_tag_ip3d_n
To monitor number of tracks used to evaluate IP3D weight.
Definition: JetTagMonitoring.h:184
Generated on Tue Jul 2 2024 21:18:54 for ATLAS Offline Software by   doxygen 1.8.18