ATLAS Offline Software
PhysValMET.cxx
Go to the documentation of this file.
1 
3 /*
4  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
5 */
6 
7 // PhysValMET.cxx
8 // Implementation file for class PhysValMET
9 // Author: Daniel Buescher <daniel.buescher@cern.ch>, Philipp Mogg <philipp.mogg@cern.ch>
11 
12 // PhysVal includes
13 #include "PhysValMET.h"
14 
15 // STL includes
16 #include <cmath>
17 #include <map>
18 #include <vector>
19 
20 // FrameWork includes
21 #include "GaudiKernel/IToolSvc.h"
22 #include "xAODMissingET/versions/MissingETBase.h"
23 #include "xAODMissingET/MissingET.h"
24 #include "xAODMissingET/MissingETContainer.h"
25 #include "xAODMissingET/MissingETAuxContainer.h"
26 #include "AthenaBaseComps/AthCheckMacros.h"
27 #include "xAODMissingET/MissingETComposition.h"
28 #include "xAODMissingET/MissingETAssociationMap.h"
29 #include "xAODMissingET/MissingETAssociationHelper.h"
30 
31 #include "xAODJet/JetContainer.h"
32 #include "xAODMuon/MuonContainer.h"
33 #include "xAODEgamma/ElectronContainer.h"
34 #include "xAODEgamma/PhotonContainer.h"
35 #include "xAODTau/TauJetContainer.h"
36 
37 #include "xAODTracking/Vertex.h"
38 #include "xAODTracking/VertexContainer.h"
39 #include "xAODTracking/TrackParticle.h"
40 #include "PATCore/AcceptData.h"
41 #include "METUtilities/METHelpers.h"
42 #include "AthContainers/Decorator.h"
43 
44 using namespace xAOD;
45 
46 namespace MissingEtDQA {
47 
49  // Public methods:
51 
52  // Constructors
54 
55  PhysValMET::PhysValMET( const std::string& type,
56  const std::string& name,
57  const IInterface* parent) :
58  ManagedMonitorToolBase( type, name, parent ),
59  m_metmaker(nullptr)
60  {
61  declareProperty( "InputElectrons", m_eleColl = "Electrons" );
62  declareProperty( "InputPhotons", m_gammaColl = "Photons" );
63  declareProperty( "InputTaus", m_tauColl = "TauJets" );
64  declareProperty( "InputMuons", m_muonColl = "Muons" );
65  declareProperty( "DoTruth", m_doTruth = false );
66  declareProperty( "InputIsDAOD", m_inputIsDAOD = false );
67  declareProperty( "DoMETRefPlots", m_doMETRefPlots = false );
68  declareProperty( "METMapName", m_mapname = "METAssoc" );
69  declareProperty( "METCoreName", m_corename = "MET_Core" );
70  }
71 
72  // Destructor
74  PhysValMET::~PhysValMET()
75  {
76  m_names.clear();
77  m_types.clear();
78  m_terms.clear();
79  m_MET_Ref.clear();
80  m_MET_Ref_x.clear();
81  m_MET_Ref_y.clear();
82  m_MET_Ref_phi.clear();
83  m_MET_Ref_sum.clear();
84  m_MET_Diff_Ref.clear();
85  m_MET_Diff_Ref_x.clear();
86  m_MET_Diff_Ref_y.clear();
87  m_MET_Diff_Ref_phi.clear();
88  m_MET_Diff_Ref_sum.clear();
89  m_MET_Cumu_Ref.clear();
90  m_MET_Resolution_Ref.clear();
91  m_MET_Significance_Ref.clear();
92  m_MET_dPhi_Ref.clear();
93  m_MET_CorrFinalTrk_Ref.clear();
94  m_MET_CorrFinalClus_Ref.clear();
95  m_MET_Reb.clear();
96  m_MET_Reb_x.clear();
97  m_MET_Reb_y.clear();
98  m_MET_Reb_phi.clear();
99  m_MET_Reb_sum.clear();
100  m_MET_Diff_Reb.clear();
101  m_MET_Diff_Reb_x.clear();
102  m_MET_Diff_Reb_y.clear();
103  m_MET_Diff_Reb_phi.clear();
104  m_MET_Diff_Reb_sum.clear();
105  m_MET_Cumu_Reb.clear();
106  m_MET_Resolution_Reb.clear();
107  m_MET_Significance_Reb.clear();
108  m_MET_dPhi_Reb.clear();
109  m_MET_CorrFinalTrk_Reb.clear();
110  m_MET_CorrFinalClus_Reb.clear();
111 }
112 
113  // Athena algtool's Hooks
115  StatusCode PhysValMET::initialize()
116  {
117  ATH_MSG_INFO ("Initializing " << name() << "...");
118  ATH_CHECK(ManagedMonitorToolBase::initialize());
119 
120  m_names.clear();
121  m_names["RefEle"] = "Electron term";
122  m_names["RefGamma"] = "Photon term";
123  m_names["RefTau"] = "Tau term";
124  m_names["Muons"] = "Muon term";
125  m_names["RefJet"] = "Jet term";
126  m_names["SoftClus"] = "Cluster-based soft term";
127  m_names["PVSoftTrk"] = "Track-based soft term (PV-matched)";
128  m_names["FinalTrk"] = "Total MET with TST";
129  m_names["FinalClus"] = "Total MET with CST";
130  m_names["Track"] = "Track MET, loose selection";
131  m_names["PVTrack_Nominal"] = "Track MET for highest sum p_{T}^{2} PV";
132  m_names["PVTrack_Pileup"] = "Track MET for each pileup vertex";
133 
134  m_types.clear();
135  m_types.emplace_back("AntiKt4EMTopo");
136  m_types.emplace_back("AntiKt4EMPFlow");
137 
138  m_terms.clear();
139  m_terms.emplace_back("RefEle");
140  m_terms.emplace_back("RefGamma");
141  m_terms.emplace_back("RefTau");
142  m_terms.emplace_back("Muons");
143  m_terms.emplace_back("RefJet");
144  m_terms.emplace_back("SoftClus");
145  m_terms.emplace_back("PVSoftTrk");
146  m_terms.emplace_back("FinalTrk");
147  m_terms.emplace_back("FinalClus");
148 
149  ATH_MSG_INFO("Retrieving tools...");
150 
151  ATH_CHECK( m_metmakerTopo.retrieve() );
152  ATH_CHECK( m_metmakerPFlow.retrieve() );
153  ATH_CHECK( m_muonSelTool.retrieve() );
154  ATH_CHECK( m_elecSelLHTool.retrieve() );
155  ATH_CHECK( m_photonSelIsEMTool.retrieve() );
156  ATH_CHECK( m_tauSelTool.retrieve() );
157  ATH_CHECK( m_jvtToolEM.retrieve() );
158  ATH_CHECK( m_jvtToolPFlow.retrieve() );
159  m_MET_Ref.clear();
160  m_MET_Ref_x.clear();
161  m_MET_Ref_y.clear();
162  m_MET_Ref_phi.clear();
163  m_MET_Ref_sum.clear();
164  m_MET_Diff_Ref.clear();
165  m_MET_Diff_Ref_x.clear();
166  m_MET_Diff_Ref_y.clear();
167  m_MET_Diff_Ref_phi.clear();
168  m_MET_Diff_Ref_sum.clear();
169  m_MET_Cumu_Ref.clear();
170  m_MET_Resolution_Ref.clear();
171  m_MET_Significance_Ref.clear();
172  m_MET_dPhi_Ref.clear();
173  m_MET_CorrFinalTrk_Ref.clear();
174  m_MET_CorrFinalClus_Ref.clear();
175  m_MET_Reb.clear();
176  m_MET_Reb_x.clear();
177  m_MET_Reb_y.clear();
178  m_MET_Reb_phi.clear();
179  m_MET_Reb_sum.clear();
180  m_MET_Diff_Reb.clear();
181  m_MET_Diff_Reb_x.clear();
182  m_MET_Diff_Reb_y.clear();
183  m_MET_Diff_Reb_phi.clear();
184  m_MET_Diff_Reb_sum.clear();
185  m_MET_Cumu_Reb.clear();
186  m_MET_Resolution_Reb.clear();
187  m_MET_Significance_Reb.clear();
188  m_MET_dPhi_Reb.clear();
189  m_MET_CorrFinalTrk_Reb.clear();
190  m_MET_CorrFinalClus_Reb.clear();
191 
192  return StatusCode::SUCCESS;
193  }
194 
195  StatusCode PhysValMET::bookHistograms()
196  {
197  ATH_MSG_INFO ("Booking hists " << name() << "...");
198 
199  // Physics validation plots are level 10
200 
201  int nbinp = 100;
202  int nbinpxy = 100;
203  int nbinphi = 63;
204  int nbinE = 100;
205  double suptmi = 500.;
206  double suptmixy = 250.;
207  double binphi = 3.15;
208  double lowET = 0.;
209  double suET = 2500.;
210 
211  if (m_detailLevel >= 10) {
212 
213  for (const auto& type : m_types){
214  std::string name_met;
215  std::string name_sub;
216  std::vector<std::string> corrClus_names;
217  std::vector<std::string> corrTrk_names;
218  std::vector<std::string> sum_names;
219  std::string dir;
220 
221  corrClus_names.emplace_back("RefEle");
222  corrClus_names.emplace_back("RefGamma");
223  corrClus_names.emplace_back("RefTau");
224  corrClus_names.emplace_back("Muons");
225  corrClus_names.emplace_back("RefJet");
226  corrClus_names.emplace_back("SoftClus");
227 
228  corrTrk_names.emplace_back("RefEle");
229  corrTrk_names.emplace_back("RefGamma");
230  corrTrk_names.emplace_back("RefTau");
231  corrTrk_names.emplace_back("Muons");
232  corrTrk_names.emplace_back("RefJet");
233  corrTrk_names.emplace_back("PVSoftTrk");
234 
235  sum_names.emplace_back("RefEle");
236  sum_names.emplace_back("RefGamma");
237  sum_names.emplace_back("RefTau");
238  sum_names.emplace_back("Muons");
239  sum_names.emplace_back("RefJet");
240 
241  //-------------------------------------------------------------------------------------
242  // First set-up Reference MET histograms (if we want them)
243  if (m_doMETRefPlots){
244  name_met = "MET_Reference_" + type;
245  m_dir_met.clear();
246  std::vector<TH1D*> v_MET_Ref;
247  std::vector<TH1D*> v_MET_Ref_x;
248  std::vector<TH1D*> v_MET_Ref_y;
249  std::vector<TH1D*> v_MET_Ref_phi;
250  std::vector<TH1D*> v_MET_Ref_sum;
251  std::vector<TH1D*> v_MET_Cumu_Ref;
252  std::vector<TH1D*> v_MET_Resolution_Ref;
253  std::vector<TH1D*> v_MET_Significance_Ref;
254  std::vector<TH1D*> v_MET_dPhi_Ref;
255  std::vector<TH2D*> v_MET_CorrFinalTrk_Ref;
256  std::vector<TH2D*> v_MET_CorrFinalClus_Ref;
257  std::vector<TH1D*> v_MET_Diff_Ref;
258  std::vector<TH1D*> v_MET_Diff_Ref_x;
259  std::vector<TH1D*> v_MET_Diff_Ref_y;
260  std::vector<TH1D*> v_MET_Diff_Ref_phi;
261  std::vector<TH1D*> v_MET_Diff_Ref_sum;
262 
263  for(const auto& term : m_terms) {
264  v_MET_Ref.push_back( new TH1D((name_met + "_" + term).c_str(), (name_met + " " + m_names[term] + "; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
265  v_MET_Ref_x.push_back( new TH1D((name_met + "_" + term +"_x").c_str(), (name_met + " " + m_names[term] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
266  v_MET_Ref_y.push_back( new TH1D((name_met + "_" + term + "_y").c_str(), (name_met + " " + m_names[term] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
267  v_MET_Ref_phi.push_back( new TH1D((name_met + "_" + term + "_phi").c_str(), (name_met + " " + m_names[term] + " phi; #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi) );
268  v_MET_Ref_sum.push_back( new TH1D((name_met + "_" + term + "_sum").c_str(), (name_met + " " + m_names[term] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET) );
269  m_dir_met.push_back("MET/" + name_met + "/Terms/" + term + "/");
270  }
271 
272  m_MET_Ref[type] = v_MET_Ref;
273  m_MET_Ref_x[type] = v_MET_Ref_x;
274  m_MET_Ref_y[type] = v_MET_Ref_y;
275  m_MET_Ref_phi[type] = v_MET_Ref_phi;
276  m_MET_Ref_sum[type] = v_MET_Ref_sum;
277 
278  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Ref.size(); ++i) {
279  ATH_CHECK(regHist(m_MET_Ref[type].at(i),m_dir_met[i],all));
280  ATH_CHECK(regHist(m_MET_Ref_x[type].at(i),m_dir_met[i],all));
281  ATH_CHECK(regHist(m_MET_Ref_y[type].at(i),m_dir_met[i],all));
282  ATH_CHECK(regHist(m_MET_Ref_phi[type].at(i),m_dir_met[i],all));
283  ATH_CHECK(regHist(m_MET_Ref_sum[type].at(i),m_dir_met[i],all));
284  }
285 
286  name_sub = name_met + "/Cumulative";
287  v_MET_Cumu_Ref.push_back( new TH1D((name_met + "_Cumulative_FinalClus").c_str(), (name_met + " CST MET cumulative; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
288  v_MET_Cumu_Ref.push_back( new TH1D((name_met + "_Cumulative_FinalTrk").c_str(), (name_met + " TST MET cumulative; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
289 
290  m_MET_Cumu_Ref[type] = v_MET_Cumu_Ref;
291 
292  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Cumu_Ref.size(); ++i) {
293  ATH_CHECK(regHist(m_MET_Cumu_Ref[type].at(i),"MET/" + name_sub + "/",all));
294  }
295 
296  name_sub = name_met + "/Residuals";
297  v_MET_Resolution_Ref.push_back( new TH1D((name_met + "_Resolution_FinalClus_x").c_str(), ("x-Residual of CST MET in " + name_met + "; #Delta(E_{T,CST}^{miss}, E_{T,truth}^{miss})_{x} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
298  v_MET_Resolution_Ref.push_back( new TH1D((name_met + "_Resolution_FinalClus_y").c_str(), ("y-Residual of CST MET in " + name_met + "; #Delta(E_{T,CST}^{miss}, E_{T,truth}^{miss})_{y} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
299  v_MET_Resolution_Ref.push_back( new TH1D((name_met + "_Resolution_FinalTrk_x").c_str(), ("x-Residual of TST MET in " + name_met + "; #Delta(E_{T,TST}^{miss}, E_{T,truth}^{miss})_{x} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
300  v_MET_Resolution_Ref.push_back( new TH1D((name_met + "_Resolution_FinalTrk_y").c_str(), ("y-Residual of TST MET in " + name_met + "; #Delta(E_{T,TST}^{miss}, E_{T,truth}^{miss})_{y} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
301 
302  m_MET_Resolution_Ref[type] = v_MET_Resolution_Ref;
303 
304  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Resolution_Ref.size(); ++i) {
305  ATH_CHECK(regHist(m_MET_Resolution_Ref[type].at(i),"MET/" + name_sub + "/",all));
306  }
307 
308  name_sub = name_met + "/Significance";
309  v_MET_Significance_Ref.push_back( new TH1D((name_met + "_Significance_FinalClus").c_str(), ("MET / sqrt(sumet) for " + name_met + " CST; MET/#sqrt{SET} [#sqrt{GeV}]; Entries / 0.25 #sqrt{GeV}").c_str(), nbinp, 0., 25.) );
310  v_MET_Significance_Ref.push_back( new TH1D((name_met + "_Significance_FinalTrk").c_str(), ("MET / sqrt(sumet) for " + name_met + " TST; MET/#sqrt{SET} [#sqrt{GeV}]; Entries / 0.25 #sqrt{GeV}").c_str(), nbinp, 0., 25.) );
311 
312  m_MET_Significance_Ref[type] = v_MET_Significance_Ref;
313 
314  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Significance_Ref.size(); ++i) {
315  ATH_CHECK(regHist(m_MET_Significance_Ref[type].at(i),"MET/" + name_sub + "/",all));
316  }
317 
318  name_sub = name_met + "/dPhi";
319  v_MET_dPhi_Ref.push_back( new TH1D((name_met + "_dPhi_leadJetMET_FinalClus").c_str(), ("MET deltaPhi vs leading jet for " + name_met + " CST; #Delta#Phi(leadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
320  v_MET_dPhi_Ref.push_back( new TH1D((name_met + "_dPhi_subleadJetMET_FinalClus").c_str(), ("MET deltaPhi vs subleading jet for " + name_met + " CST; #Delta#Phi(subleadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
321  v_MET_dPhi_Ref.push_back( new TH1D((name_met + "_dPhi_leadLepMET_FinalClus").c_str(), ("MET deltaPhi vs leading lepton for " + name_met + " CST; #Delta#Phi(leadLep, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
322  v_MET_dPhi_Ref.push_back( new TH1D((name_met + "_dPhi_leadJetMET_FinalTrk").c_str(), ("MET deltaPhi vs leading jet for " + name_met + " TST; #Delta#Phi(leadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
323  v_MET_dPhi_Ref.push_back( new TH1D((name_met + "_dPhi_subleadJetMET_FinalTrk").c_str(), ("MET deltaPhi vs subleading jet for " + name_met + " TST; #Delta#Phi(subleadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
324  v_MET_dPhi_Ref.push_back( new TH1D((name_met + "_dPhi_leadLepMET_FinalTrk").c_str(), ("MET deltaPhi vs leading lepton for " + name_met + " TST; #Delta#Phi(leadLep, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
325 
326  m_MET_dPhi_Ref[type] = v_MET_dPhi_Ref;
327 
328  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_dPhi_Ref.size(); ++i) {
329  ATH_CHECK(regHist(m_MET_dPhi_Ref[type].at(i),"MET/" + name_sub + "/",all));
330  }
331 
332  name_sub = name_met + "/Correlations";
333 
334  v_MET_CorrFinalClus_Ref.reserve(corrClus_names.size());
335 
336  for(const auto& it : corrClus_names) {
337  v_MET_CorrFinalClus_Ref.push_back( new TH2D((name_met + "_" + it + "_FinalClus").c_str(), (name_met + " " + m_names[it] + " vs. CST MET; E_{T," + it + "}^{miss} [GeV]; E_{T,CST}^{miss} [GeV]; Entries").c_str(), nbinp, 0., suptmi, nbinp, 0., suptmi) );
338  }
339  v_MET_CorrFinalTrk_Ref.reserve(corrTrk_names.size());
340 
341  for(const auto& it : corrTrk_names) {
342  v_MET_CorrFinalTrk_Ref.push_back( new TH2D((name_met + "_" + it + "_FinalTrk").c_str(), (name_met + " " + m_names[it] + " vs. TST MET; E_{T," + it + "}^{miss} [GeV]; E_{T,TST}^{miss} [GeV]; Entries").c_str(), nbinp, 0., suptmi, nbinp, 0., suptmi) );
343  }
344 
345  m_MET_CorrFinalClus_Ref[type] = v_MET_CorrFinalClus_Ref;
346  m_MET_CorrFinalTrk_Ref[type] = v_MET_CorrFinalTrk_Ref;
347 
348  for(std::vector<TH2D*>::size_type i = 0; i < v_MET_CorrFinalTrk_Ref.size(); ++i) {
349  ATH_CHECK(regHist(m_MET_CorrFinalTrk_Ref[type].at(i),"MET/" + name_sub + "/",all));
350  }
351  for(std::vector<TH2D*>::size_type i = 0; i < v_MET_CorrFinalClus_Ref.size(); ++i) {
352  ATH_CHECK(regHist(m_MET_CorrFinalClus_Ref[type].at(i),"MET/" + name_sub + "/",all));
353  }
354 
355  m_dir_met.clear();
356 
357  for(const auto& it : sum_names) {
358  v_MET_Diff_Ref.push_back( new TH1D((name_met + "_Diff_" + it).c_str(), ("MET_Diff " + m_names[it] + " in " + name_met +"; E_{T}^{miss} - #Sigma p_{T} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150));
359  v_MET_Diff_Ref_x.push_back( new TH1D((name_met + "_Diff_" + it +"_x").c_str(), ("MET_Diff x " + m_names[it] + " in " + name_met +"; E_{x}^{miss} - #Sigma p_{x} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150) );
360  v_MET_Diff_Ref_y.push_back( new TH1D((name_met + "_Diff_" + it +"_y").c_str(), ("MET_Diff y " + m_names[it] + " in " + name_met +"; E_{y}^{miss} - #Sigma p_{y} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150) );
361  v_MET_Diff_Ref_phi.push_back( new TH1D((name_met + "_Diff_" + it +"_phi").c_str(), ("MET_Diff phi " + m_names[it] + " in " + name_met +"; #Delta#Phi(E_{T}^{miss},#Sigma p_{T}); Entries / 0.1").c_str(), nbinphi,-binphi,binphi) );
362  v_MET_Diff_Ref_sum.push_back( new TH1D((name_met + "_Diff_" + it +"_sum").c_str(), ("MET_Diff sumet " + m_names[it] + " in " + name_met +"; E_{T}^{sum} - #Sigma |p_{T}| [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -250, 250) );
363  m_dir_met.push_back("MET/" + name_met + "/Differences/" + it + "/");
364  }
365 
366  m_MET_Diff_Ref[type] = v_MET_Diff_Ref;
367  m_MET_Diff_Ref_x[type] = v_MET_Diff_Ref_x;
368  m_MET_Diff_Ref_y[type] = v_MET_Diff_Ref_y;
369  m_MET_Diff_Ref_phi[type] = v_MET_Diff_Ref_phi;
370  m_MET_Diff_Ref_sum[type] = v_MET_Diff_Ref_sum;
371 
372  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Diff_Ref.size(); ++i) {
373  ATH_CHECK(regHist(m_MET_Diff_Ref[type].at(i),m_dir_met[i],all));
374  ATH_CHECK(regHist(m_MET_Diff_Ref_x[type].at(i),m_dir_met[i],all));
375  ATH_CHECK(regHist(m_MET_Diff_Ref_y[type].at(i),m_dir_met[i],all));
376  ATH_CHECK(regHist(m_MET_Diff_Ref_phi[type].at(i),m_dir_met[i],all));
377  ATH_CHECK(regHist(m_MET_Diff_Ref_sum[type].at(i),m_dir_met[i],all));
378  }
379  // End of if-statement (m_doMETRefPlots)
380  }
381 
382  //-------------------------------------------------------------------------------------
383  // Now the same for Rebuilt MET
384 
385  name_met = "MET_Rebuilt_" + type;
386  m_dir_met.clear();
387  std::vector<TH1D*> v_MET_Reb;
388  std::vector<TH1D*> v_MET_Reb_x;
389  std::vector<TH1D*> v_MET_Reb_y;
390  std::vector<TH1D*> v_MET_Reb_phi;
391  std::vector<TH1D*> v_MET_Reb_sum;
392  std::vector<TH1D*> v_MET_Cumu_Reb;
393  std::vector<TH1D*> v_MET_Resolution_Reb;
394  std::vector<TH1D*> v_MET_Significance_Reb;
395  std::vector<TH1D*> v_MET_dPhi_Reb;
396  std::vector<TH2D*> v_MET_CorrFinalTrk_Reb;
397  std::vector<TH2D*> v_MET_CorrFinalClus_Reb;
398  std::vector<TH1D*> v_MET_Diff_Reb;
399  std::vector<TH1D*> v_MET_Diff_Reb_x;
400  std::vector<TH1D*> v_MET_Diff_Reb_y;
401  std::vector<TH1D*> v_MET_Diff_Reb_phi;
402  std::vector<TH1D*> v_MET_Diff_Reb_sum;
403 
404  for(const auto& term : m_terms) {
405  v_MET_Reb.push_back( new TH1D((name_met + "_" + term).c_str(), (name_met + " " + m_names[term] + "; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
406  v_MET_Reb_x.push_back( new TH1D((name_met + "_" + term + "_x").c_str(), (name_met + " " + m_names[term] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
407  v_MET_Reb_y.push_back( new TH1D((name_met + "_" + term + "_y").c_str(), (name_met + " " + m_names[term] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
408  v_MET_Reb_phi.push_back( new TH1D((name_met + "_" + term + "_phi").c_str(), (name_met + " " + m_names[term] + " phi; #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi) );
409  v_MET_Reb_sum.push_back( new TH1D((name_met + "_" + term + "_sum").c_str(), (name_met + " " + m_names[term] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET) );
410  m_dir_met.push_back("MET/" + name_met + "/Terms/" + term + "/");
411  }
412 
413  m_MET_Reb[type] = v_MET_Reb;
414  m_MET_Reb_x[type] = v_MET_Reb_x;
415  m_MET_Reb_y[type] = v_MET_Reb_y;
416  m_MET_Reb_phi[type] = v_MET_Reb_phi;
417  m_MET_Reb_sum[type] = v_MET_Reb_sum;
418 
419  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Reb.size(); ++i) {
420  ATH_CHECK(regHist(m_MET_Reb[type].at(i),m_dir_met[i],all));
421  ATH_CHECK(regHist(m_MET_Reb_x[type].at(i),m_dir_met[i],all));
422  ATH_CHECK(regHist(m_MET_Reb_y[type].at(i),m_dir_met[i],all));
423  ATH_CHECK(regHist(m_MET_Reb_phi[type].at(i),m_dir_met[i],all));
424  ATH_CHECK(regHist(m_MET_Reb_sum[type].at(i),m_dir_met[i],all));
425  }
426 
427  name_sub = name_met + "/Cumulative";
428  v_MET_Cumu_Reb.push_back( new TH1D((name_met + "_Cumulative_FinalClus").c_str(), (name_met + " CST MET cumulative; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
429  v_MET_Cumu_Reb.push_back( new TH1D((name_met + "_Cumulative_FinalTrk").c_str(), (name_met + " TST MET cumulative; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
430 
431  m_MET_Cumu_Reb[type] = v_MET_Cumu_Reb;
432 
433  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Cumu_Reb.size(); ++i) {
434  ATH_CHECK(regHist(m_MET_Cumu_Reb[type].at(i),"MET/" + name_sub + "/",all));
435  }
436 
437  name_sub = name_met + "/Residuals";
438  v_MET_Resolution_Reb.push_back( new TH1D((name_met + "_Resolution_FinalClus_x").c_str(), ("x-Residual of CST MET in " + name_met + "; #Delta(E_{T,CST}^{miss}, E_{T,truth}^{miss})_{x} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
439  v_MET_Resolution_Reb.push_back( new TH1D((name_met + "_Resolution_FinalClus_y").c_str(), ("y-Residual of CST MET in " + name_met + "; #Delta(E_{T,CST}^{miss}, E_{T,truth}^{miss})_{y} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
440  v_MET_Resolution_Reb.push_back( new TH1D((name_met + "_Resolution_FinalTrk_x").c_str(), ("x-Residual of TST MET in " + name_met + "; #Delta(E_{T,TST}^{miss}, E_{T,truth}^{miss})_{x} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
441  v_MET_Resolution_Reb.push_back( new TH1D((name_met + "_Resolution_FinalTrk_y").c_str(), ("y-Residual of TST MET in " + name_met + "; #Delta(E_{T,TST}^{miss}, E_{T,truth}^{miss})_{y} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
442  m_MET_Resolution_Reb[type] = v_MET_Resolution_Reb;
443 
444  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Resolution_Reb.size(); ++i) {
445  ATH_CHECK(regHist(m_MET_Resolution_Reb[type].at(i),"MET/" + name_sub + "/",all));
446  }
447 
448  name_sub = name_met + "/Significance";
449  v_MET_Significance_Reb.push_back( new TH1D((name_met + "_Significance_FinalClus").c_str(), ("MET / sqrt(sumet) for " + name_met + " CST; MET/#sqrt{SET} [#sqrt{GeV}]; Entries / 0.25 #sqrt{GeV}").c_str(), nbinp, 0., 25.) );
450  v_MET_Significance_Reb.push_back( new TH1D((name_met + "_Significance_FinalTrk").c_str(), ("MET / sqrt(sumet) for " + name_met + " TST; MET/sqrt{SET} [#sqrt{GeV}]; Entries / 0.25 #sqrt{GeV}").c_str(), nbinp, 0., 25.) );
451 
452  m_MET_Significance_Reb[type] = v_MET_Significance_Reb;
453 
454  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Significance_Reb.size(); ++i) {
455  ATH_CHECK(regHist(m_MET_Significance_Reb[type].at(i),"MET/" + name_sub + "/",all));
456  }
457 
458  name_sub = name_met + "/dPhi";
459  v_MET_dPhi_Reb.push_back( new TH1D((name_met + "_dPhi_leadJetMET_FinalClus").c_str(), ("MET deltaPhi vs leading jet for " + name_met + " CST; #Delta#Phi(leadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
460  v_MET_dPhi_Reb.push_back( new TH1D((name_met + "_dPhi_subleadJetMET_FinalClus").c_str(), ("MET deltaPhi vs subleading jet for " + name_met + " CST; #Delta#Phi(subleadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
461  v_MET_dPhi_Reb.push_back( new TH1D((name_met + "_dPhi_leadLepMET_FinalClus").c_str(), ("MET deltaPhi vs leading lepton for " + name_met + " CST; #Delta#Phi(leadLep, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
462  v_MET_dPhi_Reb.push_back( new TH1D((name_met + "_dPhi_leadJetMET_FinalTrk").c_str(), ("MET deltaPhi vs leading jet for " + name_met + " TST; #Delta#Phi(leadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
463  v_MET_dPhi_Reb.push_back( new TH1D((name_met + "_dPhi_subleadJetMET_FinalTrk").c_str(), ("MET deltaPhi vs subleading jet for " + name_met + " TST; #Delta#Phi(subleadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
464  v_MET_dPhi_Reb.push_back( new TH1D((name_met + "_dPhi_leadLepMET_FinalTrk").c_str(), ("MET deltaPhi vs leading lepton for " + name_met + " TST; #Delta#Phi(leadLep, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
465 
466  m_MET_dPhi_Reb[type] = v_MET_dPhi_Reb;
467 
468  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_dPhi_Reb.size(); ++i) {
469  ATH_CHECK(regHist(m_MET_dPhi_Reb[type].at(i),"MET/" + name_sub + "/",all));
470  }
471 
472  name_sub = name_met + "/Correlations";
473  v_MET_CorrFinalClus_Reb.reserve(corrClus_names.size());
474 
475  for(const auto& it : corrClus_names) {
476  v_MET_CorrFinalClus_Reb.push_back( new TH2D((name_met + "_" + it + "_FinalClus").c_str(), (name_met + " " + m_names[it] + " vs. CST MET; E_{T," + it + "}^{miss} [GeV]; E_{T,CST}^{miss} [GeV]; Entries").c_str(), nbinp, 0., suptmi, nbinp, 0., suptmi) );
477  }
478  v_MET_CorrFinalTrk_Reb.reserve(corrTrk_names.size());
479 
480  for(const auto& it : corrTrk_names) {
481  v_MET_CorrFinalTrk_Reb.push_back( new TH2D((name_met + "_" + it + "_FinalTrk").c_str(), (name_met + " " + m_names[it] + " vs. TST MET; E_{T," + it + "}^{miss} [GeV]; E_{T,TST}^{miss} [GeV]; Entries").c_str(), nbinp, 0., suptmi, nbinp, 0., suptmi) );
482  }
483 
484  m_MET_CorrFinalClus_Reb[type] = v_MET_CorrFinalClus_Reb;
485  m_MET_CorrFinalTrk_Reb[type] = v_MET_CorrFinalTrk_Reb;
486 
487  for(std::vector<TH2D*>::size_type i = 0; i < v_MET_CorrFinalTrk_Reb.size(); ++i) {
488  ATH_CHECK(regHist(m_MET_CorrFinalTrk_Reb[type].at(i),"MET/" + name_sub + "/",all));
489  }
490  for(std::vector<TH2D*>::size_type i = 0; i < v_MET_CorrFinalClus_Reb.size(); ++i) {
491  ATH_CHECK(regHist(m_MET_CorrFinalClus_Reb[type].at(i),"MET/" + name_sub + "/",all));
492  }
493 
494  m_dir_met.clear();
495 
496  for(const auto& it : sum_names) {
497  v_MET_Diff_Reb.push_back( new TH1D((name_met + "_Diff_" + it).c_str(), ("MET_Diff " + m_names[it] + " in " + name_met +"; E_{T}^{miss} - #Sigma p_{T} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150));
498  v_MET_Diff_Reb_x.push_back( new TH1D((name_met + "_Diff_" + it + "_x").c_str(), ("MET_Diff x " + m_names[it] + " in " + name_met +"; E_{x}^{miss} - #Sigma p_{x} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150) );
499  v_MET_Diff_Reb_y.push_back( new TH1D((name_met + "_Diff_" + it + "_y").c_str(), ("MET_Diff y " + m_names[it] + " in " + name_met +"; E_{y}^{miss} - #Sigma p_{y} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150) );
500  v_MET_Diff_Reb_phi.push_back( new TH1D((name_met + "_Diff_" + it + "_phi").c_str(), ("MET_Diff phi " + m_names[it] + " in " + name_met +"; #Delta#Phi(E_{T}^{miss}, #Sigma p_{T}); Entries / 0.1").c_str(), nbinphi,-binphi,binphi) );
501  v_MET_Diff_Reb_sum.push_back( new TH1D((name_met + "_Diff_" + it + "_sum").c_str(), ("MET_Diff sumet " + m_names[it] + " in " + name_met +"; E_{T}^{sum} - #Sigma |p_{T}| [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -250, 250) );
502  m_dir_met.push_back("MET/" + name_met + "/Differences/" + it + "/");
503  }
504 
505  m_MET_Diff_Reb[type] = v_MET_Diff_Reb;
506  m_MET_Diff_Reb_x[type] = v_MET_Diff_Reb_x;
507  m_MET_Diff_Reb_y[type] = v_MET_Diff_Reb_y;
508  m_MET_Diff_Reb_phi[type] = v_MET_Diff_Reb_phi;
509  m_MET_Diff_Reb_sum[type] = v_MET_Diff_Reb_sum;
510 
511  for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Diff_Reb.size(); ++i) {
512  ATH_CHECK(regHist(m_MET_Diff_Reb[type].at(i),m_dir_met[i],all));
513  ATH_CHECK(regHist(m_MET_Diff_Reb_x[type].at(i),m_dir_met[i],all));
514  ATH_CHECK(regHist(m_MET_Diff_Reb_y[type].at(i),m_dir_met[i],all));
515  ATH_CHECK(regHist(m_MET_Diff_Reb_phi[type].at(i),m_dir_met[i],all));
516  ATH_CHECK(regHist(m_MET_Diff_Reb_sum[type].at(i),m_dir_met[i],all));
517  }
518  }
519 
520  //-------------------------------------------------------------------------------------
521  // Now MET_Track (only built if METRef is too)
522  if (m_doMETRefPlots){
523  std::string name_met = "MET_Track";
524  std::string dir = "MET/" + name_met + "/";
525  std::string sub_dir;
526 
527  sub_dir = dir + "Track/";
528  ATH_CHECK(regHist(m_MET_Track = new TH1D("Track", (name_met + " " + m_names["Track"] + "; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi), sub_dir, all));
529  ATH_CHECK(regHist(m_MET_Track_x = new TH1D("Track_x", (name_met + " " + m_names["Track"] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
530  ATH_CHECK(regHist(m_MET_Track_y = new TH1D("Track_y", (name_met + " " + m_names["Track"] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
531  ATH_CHECK(regHist(m_MET_Track_phi = new TH1D("Track_phi", (name_met + " " + m_names["Track"] + " phi; #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi), sub_dir, all));
532  ATH_CHECK(regHist(m_MET_Track_sum = new TH1D("Track_sum", (name_met + " " + m_names["Track"] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET), sub_dir, all));
533 
534  sub_dir = dir + "PVTrack_Nominal/";
535  ATH_CHECK(regHist(m_MET_PVTrack_Nominal = new TH1D("PVTrack_Nominal", (name_met + " " + m_names["PVTrack_Nominal"] + " ; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi), sub_dir, all));
536  ATH_CHECK(regHist(m_MET_PVTrack_Nominal_x = new TH1D("PVTrack_Nominal_x", (name_met + " " + m_names["PVTrack_Nominal"] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
537  ATH_CHECK(regHist(m_MET_PVTrack_Nominal_y = new TH1D("PVTrack_Nominal_y", (name_met + " " + m_names["PVTrack_Nominal"] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
538  ATH_CHECK(regHist(m_MET_PVTrack_Nominal_phi = new TH1D("PVTrack_Nominal_phi", (name_met + " " + m_names["PVTrack_Nominal"] + " phi; #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi), sub_dir, all));
539  ATH_CHECK(regHist(m_MET_PVTrack_Nominal_sum = new TH1D("PVTrack_Nominal_sum", (name_met + " " + m_names["PVTrack_Nominal"] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET), sub_dir, all));
540 
541  sub_dir = dir + "PVTrack_Pileup/";
542  ATH_CHECK(regHist(m_MET_PVTrack_Pileup = new TH1D("PVTrack_Pileup", (name_met + " " + m_names["PVTrack_Pileup"] + "; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi), sub_dir, all));
543  ATH_CHECK(regHist(m_MET_PVTrack_Pileup_x = new TH1D("PVTrack_Pileup_x", (name_met + " " + m_names["PVTrack_Pileup"] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
544  ATH_CHECK(regHist(m_MET_PVTrack_Pileup_y = new TH1D("PVTrack_Pileup_y", (name_met +" " + m_names["PVTrack_Pileup"] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
545  ATH_CHECK(regHist(m_MET_PVTrack_Pileup_phi = new TH1D("PVTrack_Pileup_phi", (name_met + " " + m_names["PVTrack_Pileup"] + " phi; #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi), sub_dir, all));
546  ATH_CHECK(regHist(m_MET_PVTrack_Pileup_sum = new TH1D("PVTrack_Pileup_sum", (name_met + " " + m_names["PVTrack_Pileup"] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET), sub_dir, all));
547  }
548 
549  //-------------------------------------------------------------------------------------
550  //Now MET_Calo
551 
552  std::string name_met = "MET_Calo";
553  std::string dir = "MET/" + name_met + "/";
554 
555  ATH_CHECK(regHist(m_MET_Calo = new TH1D("Calo", (name_met + " " + m_names["Calo"] + "; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi), dir, all));
556  ATH_CHECK(regHist(m_MET_Calo_x = new TH1D("Calo_x", (name_met + " " + m_names["Calo"] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), dir, all));
557  ATH_CHECK(regHist(m_MET_Calo_y = new TH1D("Calo_y", (name_met + " " + m_names["Calo"] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), dir, all));
558  ATH_CHECK(regHist(m_MET_Calo_phi = new TH1D("Calo_phi", (name_met + " " + m_names["Calo"] + " phi; #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi), dir, all));
559  ATH_CHECK(regHist(m_MET_Calo_sum = new TH1D("Calo_sum", (name_met + " " + m_names["Calo"] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET), dir, all));
560 
561  }
562 
563  return StatusCode::SUCCESS;
564  }
565 
566  StatusCode PhysValMET::fillHistograms()
567  {
568  ATH_MSG_DEBUG ("Filling hists " << name() << "...");
569 
570  //If we're running over new AODs without MET containers, don't do anything!
571  if(!m_inputIsDAOD && !m_doMETRefPlots)
572  return StatusCode::SUCCESS;
573 
574  //Beamspot weight
575  const xAOD::EventInfo* eventInfo(nullptr);
576  ATH_CHECK(evtStore()->retrieve(eventInfo, "EventInfo"));
577 
578  float weight = eventInfo->beamSpotWeight();
579 
580  //Retrieve MET Truth
581  const xAOD::MissingETContainer* met_Truth = nullptr;
582  if(m_doTruth) {
583  ATH_CHECK( evtStore()->retrieve(met_Truth,"MET_Truth") );
584  if (!met_Truth) {
585  ATH_MSG_ERROR ( "Failed to retrieve MET_Truth. Exiting." );
586  return StatusCode::FAILURE;
587  }
588  }
589 
590  //Physics Objects
591  const xAOD::MuonContainer* muons = nullptr;
592  ATH_CHECK( evtStore()->retrieve(muons,m_muonColl) );
593  if (!muons) {
594  ATH_MSG_ERROR ( "Failed to retrieve Muon container. Exiting." );
595  return StatusCode::FAILURE;
596  }
597  ConstDataVector<MuonContainer> metMuons(SG::VIEW_ELEMENTS);
598  bool is_muon = 0;
599  for(const auto mu : *muons) {
600  if(Accept(mu)) {
601  metMuons.push_back(mu);
602  is_muon = 1;
603  }
604  }
605 
606  const xAOD::ElectronContainer* electrons = nullptr;
607  ATH_CHECK( evtStore()->retrieve(electrons,m_eleColl) );
608  if (!electrons) {
609  ATH_MSG_ERROR ( "Failed to retrieve Electron container. Exiting." );
610  return StatusCode::FAILURE;
611  }
612  ConstDataVector<ElectronContainer> metElectrons(SG::VIEW_ELEMENTS);
613  bool is_electron = 0;
614  for(const auto el : *electrons) {
615  if(Accept(el)) {
616  metElectrons.push_back(el);
617  is_electron = 1;
618  }
619  }
620 
621  const xAOD::PhotonContainer* photons = nullptr;
622  ATH_CHECK( evtStore()->retrieve(photons,m_gammaColl) );
623  if (!electrons) {
624  ATH_MSG_ERROR ( "Failed to retrieve Photon container. Exiting." );
625  return StatusCode::FAILURE;
626  }
627  ConstDataVector<PhotonContainer> metPhotons(SG::VIEW_ELEMENTS);
628  for(const auto ph : *photons) {
629  if(Accept(ph)) {
630  metPhotons.push_back(ph);
631  }
632  }
633 
634  const TauJetContainer* taus = nullptr;
635  ATH_CHECK( evtStore()->retrieve(taus, m_tauColl) );
636  if(!taus) {
637  ATH_MSG_ERROR("Failed to retrieve TauJet container: " << m_tauColl);
638  return StatusCode::SUCCESS;
639  }
640  ConstDataVector<TauJetContainer> metTaus(SG::VIEW_ELEMENTS);
641  for(const auto tau : *taus) {
642  if(Accept(tau)) {
643  metTaus.push_back(tau);
644  }
645  }
646 
647  // Overlap removal
648 
649  ConstDataVector<PhotonContainer>::iterator pho_itr;
650  ConstDataVector<ElectronContainer>::iterator ele_itr;
651  ConstDataVector<TauJetContainer>::iterator taujet_itr;
652  ConstDataVector<MuonContainer>::iterator mu_itr;
653  ConstDataVector<JetContainer>::iterator jetc_itr;
654 
655  //Photons
656  bool is_photon = 0;
657  ConstDataVector<PhotonContainer> metPhotonsOR(SG::VIEW_ELEMENTS);
658  for(pho_itr = metPhotons.begin(); pho_itr != metPhotons.end(); ++pho_itr ) {
659  TLorentzVector phtlv = (*pho_itr)->p4();
660  bool passOR = 1;
661  for(ele_itr = metElectrons.begin(); ele_itr != metElectrons.end(); ++ele_itr) {
662  if(phtlv.DeltaR((*ele_itr)->p4()) < 0.2) {
663  passOR = 0;
664  break;
665  }
666  }
667  if(passOR){
668  metPhotonsOR.push_back(*pho_itr);
669  is_photon = 1;
670  }
671  }
672 
673  //TauJets
674  ConstDataVector<TauJetContainer> metTausOR(SG::VIEW_ELEMENTS);
675  bool is_tau = 0;
676  for(taujet_itr = metTaus.begin(); taujet_itr != metTaus.end(); ++taujet_itr ) {
677  TLorentzVector tautlv = (*taujet_itr)->p4();
678  bool passOR = 1;
679  for(ele_itr = metElectrons.begin(); ele_itr != metElectrons.end(); ++ele_itr) {
680  if(tautlv.DeltaR((*ele_itr)->p4()) < 0.2) {
681  passOR = 0;
682  break;
683  }
684  }
685  for(pho_itr = metPhotonsOR.begin(); pho_itr != metPhotonsOR.end(); ++pho_itr) {
686  if(tautlv.DeltaR((*pho_itr)->p4()) < 0.2) {
687  passOR = 0;
688  break;
689  }
690  }
691  if(passOR){
692  metTausOR.push_back(*taujet_itr);
693  is_tau = 1;
694  }
695  }
696 
697  //Sum up the pT's of the objects
698  TLorentzVector el_tlv;
699  double sum_el = 0;
700  for(ele_itr = metElectrons.begin(); ele_itr != metElectrons.end(); ++ele_itr ) {
701  el_tlv += (*ele_itr)->p4();
702  sum_el += (*ele_itr)->pt();
703  }
704 
705  TLorentzVector mu_tlv;
706  double sum_mu = 0;
707  for(mu_itr = metMuons.begin(); mu_itr != metMuons.end(); ++mu_itr ) {
708  mu_tlv += (*mu_itr)->p4();
709  sum_mu += (*mu_itr)->pt();
710  }
711 
712  TLorentzVector tau_tlv;
713  double sum_tau = 0;
714  for(taujet_itr = metTausOR.begin(); taujet_itr != metTausOR.end(); ++taujet_itr ) {
715  tau_tlv += (*taujet_itr)->p4();
716  sum_tau += (*taujet_itr)->pt();
717  }
718 
719  TLorentzVector photon_tlv;
720  double sum_photon = 0;
721  for(pho_itr = metPhotonsOR.begin(); pho_itr != metPhotonsOR.end(); ++pho_itr ) {
722  photon_tlv += (*pho_itr)->p4();
723  sum_photon += (*pho_itr)->pt();
724  }
725 
726  for (const auto& type : m_types){
727  ToolHandle<IJetUpdateJvt>* jvtTool(nullptr);
728  double JvtCut = 0.59;
729  if (type == "AntiKt4EMPFlow"){
730  JvtCut = 0.2;
731  jvtTool = &m_jvtToolPFlow;
732  }
733  else if (type == "AntiKt4EMTopo"){
734  jvtTool = &m_jvtToolEM;
735  }
736 
737  if(jvtTool == nullptr){
738  ATH_MSG_ERROR("Unrecognized jet container: " << type << "Jets");
739  return StatusCode::FAILURE;
740  }
741 
742  // Retrieve Jets
743  std::string name_jet = type + "Jets";
744  const xAOD::JetContainer* jets = nullptr;
745  ATH_CHECK( evtStore()->retrieve(jets,name_jet) );
746  if (!jets) {
747  ATH_MSG_ERROR ( "Failed to retrieve Jet container: " << name_jet << ". Exiting." );
748  return StatusCode::FAILURE;
749  }
750  SG::Decorator<float> NewJvtDec("NewJvt");
751  for(auto jet : *jets) {
752  float newjvt = (*jvtTool)->updateJvt(*jet);
753  NewJvtDec(*jet) = newjvt;
754  }
755  ConstDataVector<JetContainer> metJets(SG::VIEW_ELEMENTS);
756  for(const auto jet : *jets) {
757  metJets.push_back(jet);
758  }
759  //Overlap Removal
760  ConstDataVector<JetContainer> metJetsOR(SG::VIEW_ELEMENTS);
761  bool is_jet = 0;
762  for(jetc_itr = metJets.begin(); jetc_itr != metJets.end(); ++jetc_itr ) {
763  TLorentzVector jettlv = (*jetc_itr)->p4();
764  bool passOR = 1;
765  for(ele_itr = metElectrons.begin(); ele_itr != metElectrons.end(); ++ele_itr) {
766  if(jettlv.DeltaR((*ele_itr)->p4()) < 0.2) {
767  passOR = 0;
768  break;
769  }
770  }
771  for(pho_itr = metPhotonsOR.begin(); pho_itr != metPhotonsOR.end(); ++pho_itr) {
772  if(jettlv.DeltaR((*pho_itr)->p4()) < 0.2) {
773  passOR = 0;
774  break;
775  }
776  }
777  for(taujet_itr = metTausOR.begin(); taujet_itr != metTausOR.end(); ++taujet_itr) {
778  if(jettlv.DeltaR((*taujet_itr)->p4()) < 0.2) {
779  passOR = 0;
780  break;
781  }
782  }
783  if(passOR){
784  metJetsOR.push_back(*jetc_itr);
785  is_jet = 1;
786  }
787  }
788 
789  TLorentzVector jet_tlv;
790  double sum_jet = 0;
791  for(jetc_itr = metJetsOR.begin(); jetc_itr != metJetsOR.end(); ++jetc_itr ) {
792  jet_tlv += (*jetc_itr)->p4();
793  sum_jet += (*jetc_itr)->pt();
794  }
795 
796  // Fill MET_Ref
797  std::string name_met = "MET_Reference_" + type;
798  const xAOD::MissingETContainer* met_Ref = nullptr;
799  // We're not building METReference anymore in derivations
800 
801  if(m_doMETRefPlots){
802 
803  // Retrieve Reference MET
804  ATH_CHECK( evtStore()->retrieve(met_Ref, name_met) );
805  if (!met_Ref) {
806  ATH_MSG_ERROR ("Couldn't retrieve " << name_met);
807  return StatusCode::FAILURE;
808  }
809 
810  ATH_MSG_INFO( " MET_Ref_" << type << ":" );
811  for(const auto it : *met_Ref) {
812  const std::string& name = it->name();
813  if(name == "RefEle"){
814  (m_MET_Ref[type]).at(0)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
815  (m_MET_Ref_x[type]).at(0)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
816  (m_MET_Ref_y[type]).at(0)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
817  (m_MET_Ref_phi[type]).at(0)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
818  (m_MET_Ref_sum[type]).at(0)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
819  }
820  if(name == "RefGamma"){
821  (m_MET_Ref[type]).at(1)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
822  (m_MET_Ref_x[type]).at(1)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
823  (m_MET_Ref_y[type]).at(1)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
824  (m_MET_Ref_phi[type]).at(1)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
825  (m_MET_Ref_sum[type]).at(1)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
826  }
827  if(name == "RefTau"){
828  (m_MET_Ref[type]).at(2)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
829  (m_MET_Ref_x[type]).at(2)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
830  (m_MET_Ref_y[type]).at(2)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
831  (m_MET_Ref_phi[type]).at(2)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
832  (m_MET_Ref_sum[type]).at(2)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
833  }
834  if(name == "Muons"){
835  (m_MET_Ref[type]).at(3)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
836  (m_MET_Ref_x[type]).at(3)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
837  (m_MET_Ref_y[type]).at(3)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
838  (m_MET_Ref_phi[type]).at(3)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
839  (m_MET_Ref_sum[type]).at(3)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
840  }
841  if(name == "RefJet"){
842  (m_MET_Ref[type]).at(4)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
843  (m_MET_Ref_x[type]).at(4)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
844  (m_MET_Ref_y[type]).at(4)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
845  (m_MET_Ref_phi[type]).at(4)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
846  (m_MET_Ref_sum[type]).at(4)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
847  }
848  if(name == "SoftClus"){
849  (m_MET_Ref[type]).at(5)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
850  (m_MET_Ref_x[type]).at(5)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
851  (m_MET_Ref_y[type]).at(5)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
852  (m_MET_Ref_phi[type]).at(5)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
853  (m_MET_Ref_sum[type]).at(5)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
854  }
855  if(name == "PVSoftTrk"){
856  (m_MET_Ref[type]).at(6)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
857  (m_MET_Ref_x[type]).at(6)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
858  (m_MET_Ref_y[type]).at(6)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
859  (m_MET_Ref_phi[type]).at(6)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
860  (m_MET_Ref_sum[type]).at(6)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
861  }
862  if(name == "FinalTrk"){
863  (m_MET_Ref[type]).at(7)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
864  (m_MET_Ref_x[type]).at(7)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
865  (m_MET_Ref_y[type]).at(7)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
866  (m_MET_Ref_phi[type]).at(7)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
867  (m_MET_Ref_sum[type]).at(7)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
868  }
869  if(name == "FinalClus"){
870  (m_MET_Ref[type]).at(8)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
871  (m_MET_Ref_x[type]).at(8)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
872  (m_MET_Ref_y[type]).at(8)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
873  (m_MET_Ref_phi[type]).at(8)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
874  (m_MET_Ref_sum[type]).at(8)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
875  }
876  }
877  }
878 
879  //Prepare Rebuilding MET
880  ATH_MSG_INFO( " Rebuilding MET_" << type );
881  MissingETContainer* met_Reb = new MissingETContainer();
882  if( evtStore()->record(met_Reb,("MET_Rebuilt"+type).c_str()).isFailure() ) {
883  ATH_MSG_WARNING("Unable to record MissingETContainer: MET_Rebuilt_" << type);
884  return StatusCode::FAILURE;
885  }
886  MissingETAuxContainer* met_RebAux = new MissingETAuxContainer();
887  if( evtStore()->record(met_RebAux,("MET_Rebuilt"+type+"Aux").c_str()).isFailure() ) {
888  ATH_MSG_WARNING("Unable to record MissingETAuxContainer: MET_Rebuilt" << type);
889  return StatusCode::FAILURE;
890  }
891  met_Reb->setStore(met_RebAux);
892 
893  m_mapname = "METAssoc_"+type;
894  m_corename = "MET_Core_"+type;
895  const MissingETAssociationMap* metMap = nullptr;
896  if( evtStore()->retrieve(metMap, m_mapname).isFailure() ) {
897  ATH_MSG_WARNING("Unable to retrieve MissingETAssociationMap: " << m_mapname);
898  return StatusCode::SUCCESS;
899  }
900  MissingETAssociationHelper metHelper(metMap);
901  const MissingETContainer* coreMet(nullptr);
902  if( evtStore()->retrieve(coreMet, m_corename).isFailure() ) {
903  ATH_MSG_WARNING("Unable to retrieve MissingETContainer: " << m_corename);
904  return StatusCode::SUCCESS;
905  }
906 
907  ATH_MSG_INFO( " MET_Rebuilt_" << type << ":" );
908  //Select and flag objects for final MET building ***************************
909  if( type.find("PFlow") != std::string::npos) m_metmaker = &m_metmakerPFlow;
910  else m_metmaker = &m_metmakerTopo;
911 
912  // Electrons
913  if( (*m_metmaker)->rebuildMET("RefEle", xAOD::Type::Electron, met_Reb, metElectrons.asDataVector(), metHelper).isFailure() ) {
914  ATH_MSG_WARNING("Failed to build electron term.");
915  }
916 
917  // Photons
918  if( (*m_metmaker)->rebuildMET("RefGamma", xAOD::Type::Photon, met_Reb, metPhotons.asDataVector(), metHelper).isFailure() ) {
919  ATH_MSG_WARNING("Failed to build photon term.");
920  }
921 
922  // Taus
923  if( (*m_metmaker)->rebuildMET("RefTau", xAOD::Type::Tau, met_Reb,metTaus.asDataVector(),metHelper).isFailure() ){
924  ATH_MSG_WARNING("Failed to build tau term.");
925  }
926 
927  // Muons
928  if( (*m_metmaker)->rebuildMET("Muons", xAOD::Type::Muon, met_Reb, metMuons.asDataVector(), metHelper).isFailure() ) {
929  ATH_MSG_WARNING("Failed to build muon term.");
930  }
931 
932  // Jets
933  if( (*m_metmaker)->rebuildJetMET("RefJet", "SoftClus", "PVSoftTrk", met_Reb, jets, coreMet, metHelper, true).isFailure() ) {
934  ATH_MSG_WARNING("Failed to build jet and soft terms.");
935  }
936  MissingETBase::Types::bitmask_t trksource = static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::Track);
937  if((*met_Reb)["PVSoftTrk"]) trksource = (*met_Reb)["PVSoftTrk"]->source();
938  if( met::buildMETSum("FinalTrk", met_Reb, trksource).isFailure() ){
939  ATH_MSG_WARNING("Building MET FinalTrk sum failed.");
940  }
941  MissingETBase::Types::bitmask_t clsource;
942  if (type == "AntiKt4EMTopo") clsource = static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::EMTopo);
943  else clsource = static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::UnknownSignal);
944 
945  if((*met_Reb)["SoftClus"]) clsource = (*met_Reb)["SoftClus"]->source();
946  if( met::buildMETSum("FinalClus", met_Reb, clsource).isFailure() ) {
947  ATH_MSG_WARNING("Building MET FinalClus sum failed.");
948  }
949 
950  // Fill MET_Reb
951  for(const auto it : *met_Reb) {
952  std::string name = it->name();
953  if(name == "RefEle"){
954  (m_MET_Reb[type]).at(0)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
955  (m_MET_Reb_x[type]).at(0)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
956  (m_MET_Reb_y[type]).at(0)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
957  (m_MET_Reb_phi[type]).at(0)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
958  (m_MET_Reb_sum[type]).at(0)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
959  }
960  if(name == "RefGamma"){
961  (m_MET_Reb[type]).at(1)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
962  (m_MET_Reb_x[type]).at(1)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
963  (m_MET_Reb_y[type]).at(1)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
964  (m_MET_Reb_phi[type]).at(1)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
965  (m_MET_Reb_sum[type]).at(1)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
966  }
967  if(name == "RefTau"){
968  (m_MET_Reb[type]).at(2)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
969  (m_MET_Reb_x[type]).at(2)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
970  (m_MET_Reb_y[type]).at(2)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
971  (m_MET_Reb_phi[type]).at(2)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
972  (m_MET_Reb_sum[type]).at(2)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
973  }
974  if(name == "Muons"){
975  (m_MET_Reb[type]).at(3)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
976  (m_MET_Reb_x[type]).at(3)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
977  (m_MET_Reb_y[type]).at(3)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
978  (m_MET_Reb_phi[type]).at(3)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
979  (m_MET_Reb_sum[type]).at(3)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
980  }
981  if(name == "RefJet"){
982  (m_MET_Reb[type]).at(4)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
983  (m_MET_Reb_x[type]).at(4)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
984  (m_MET_Reb_y[type]).at(4)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
985  (m_MET_Reb_phi[type]).at(4)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
986  (m_MET_Reb_sum[type]).at(4)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
987  }
988  if(name == "SoftClus"){
989  (m_MET_Reb[type]).at(5)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
990  (m_MET_Reb_x[type]).at(5)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
991  (m_MET_Reb_y[type]).at(5)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
992  (m_MET_Reb_phi[type]).at(5)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
993  (m_MET_Reb_sum[type]).at(5)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
994  }
995  if(name == "PVSoftTrk"){
996  (m_MET_Reb[type]).at(6)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
997  (m_MET_Reb_x[type]).at(6)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
998  (m_MET_Reb_y[type]).at(6)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
999  (m_MET_Reb_phi[type]).at(6)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
1000  (m_MET_Reb_sum[type]).at(6)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
1001  }
1002  if(name == "FinalTrk"){
1003  (m_MET_Reb[type]).at(7)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
1004  (m_MET_Reb_x[type]).at(7)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
1005  (m_MET_Reb_y[type]).at(7)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
1006  (m_MET_Reb_phi[type]).at(7)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
1007  (m_MET_Reb_sum[type]).at(7)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
1008  }
1009  if(name == "FinalClus"){
1010  (m_MET_Reb[type]).at(8)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
1011  (m_MET_Reb_x[type]).at(8)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
1012  (m_MET_Reb_y[type]).at(8)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
1013  (m_MET_Reb_phi[type]).at(8)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
1014  (m_MET_Reb_sum[type]).at(8)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
1015  }
1016  }
1017 
1018  //Fill MET Angles
1019  ATH_MSG_INFO( " MET_Angles :" );
1020 
1021  double leadPt = 0., subleadPt = 0., leadPhi = 0., subleadPhi = 0.;
1022 
1023  for (auto jet_itr = jets->begin(); jet_itr != jets->end(); ++jet_itr) {
1024  if ((*jet_itr)->pt() > leadPt && Accept(*jet_itr,JvtCut,jvtTool)) {
1025  subleadPt = leadPt;
1026  subleadPhi = leadPhi;
1027  leadPt = (*jet_itr)->pt();
1028  leadPhi = (*jet_itr)->phi();
1029  }
1030  else if ((*jet_itr)->pt() > subleadPt && Accept(*jet_itr,JvtCut,jvtTool)) {
1031  subleadPt = (*jet_itr)->pt();
1032  subleadPhi = (*jet_itr)->phi();
1033  }
1034  }
1035 
1036  if(m_doMETRefPlots){
1037  (m_MET_dPhi_Ref[type]).at(0)->Fill( -remainder( leadPhi - (*met_Ref)["FinalClus"]->phi(), 2*M_PI ), weight );
1038  (m_MET_dPhi_Ref[type]).at(1)->Fill( -remainder( subleadPhi - (*met_Ref)["FinalClus"]->phi(), 2*M_PI ), weight );
1039  (m_MET_dPhi_Ref[type]).at(3)->Fill( -remainder( leadPhi - (*met_Ref)["FinalTrk"]->phi(), 2*M_PI ), weight );
1040  (m_MET_dPhi_Ref[type]).at(4)->Fill( -remainder( subleadPhi - (*met_Ref)["FinalTrk"]->phi(), 2*M_PI ), weight );
1041  }
1042 
1043  (m_MET_dPhi_Reb[type]).at(0)->Fill( -remainder( leadPhi - (*met_Reb)["FinalClus"]->phi(), 2*M_PI ), weight );
1044  (m_MET_dPhi_Reb[type]).at(1)->Fill( -remainder( subleadPhi - (*met_Reb)["FinalClus"]->phi(), 2*M_PI ), weight );
1045  (m_MET_dPhi_Reb[type]).at(3)->Fill( -remainder( leadPhi - (*met_Reb)["FinalTrk"]->phi(), 2*M_PI ), weight );
1046  (m_MET_dPhi_Reb[type]).at(4)->Fill( -remainder( subleadPhi - (*met_Reb)["FinalTrk"]->phi(), 2*M_PI ), weight );
1047 
1048  leadPt = 0.; leadPhi = 0.;
1049 
1050  xAOD::MuonContainer::const_iterator muon_itr = muons->begin();
1051  xAOD::MuonContainer::const_iterator muon_end = muons->end();
1052 
1053  for( ; muon_itr != muon_end; ++muon_itr ) {
1054  if((*muon_itr)->pt() > leadPt) {
1055  leadPt = (*muon_itr)->pt();
1056  leadPhi = (*muon_itr)->phi();
1057  }
1058  }
1059 
1060  xAOD::ElectronContainer::const_iterator electron_itr = electrons->begin();
1061  xAOD::ElectronContainer::const_iterator electron_end = electrons->end();
1062 
1063  for( ; electron_itr != electron_end; ++electron_itr ) {
1064  if((*electron_itr)->pt() > leadPt) {
1065  leadPt = (*electron_itr)->pt();
1066  leadPhi = (*electron_itr)->phi();
1067  }
1068  }
1069 
1070  (m_MET_dPhi_Reb[type]).at(2)->Fill( -remainder( leadPhi - (*met_Reb)["FinalClus"]->phi(), 2*M_PI ), weight );
1071  (m_MET_dPhi_Reb[type]).at(5)->Fill( -remainder( leadPhi - (*met_Reb)["FinalTrk"]->phi(), 2*M_PI ), weight );
1072 
1073  if(m_doMETRefPlots){
1074 
1075  (m_MET_dPhi_Ref[type]).at(2)->Fill( -remainder( leadPhi - (*met_Ref)["FinalClus"]->phi(), 2*M_PI ), weight );
1076  (m_MET_dPhi_Ref[type]).at(5)->Fill( -remainder( leadPhi - (*met_Ref)["FinalTrk"]->phi(), 2*M_PI ), weight );
1077 
1078  //Fill Correlation Plots
1079  //Reference
1080  for(const auto it : *met_Ref) {
1081  const std::string& name = it->name();
1082  if(name == "RefEle"){
1083  (m_MET_CorrFinalTrk_Ref[type]).at(0)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
1084  (m_MET_CorrFinalClus_Ref[type]).at(0)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
1085  }
1086  if(name == "RefGamma"){
1087  (m_MET_CorrFinalTrk_Ref[type]).at(1)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
1088  (m_MET_CorrFinalClus_Ref[type]).at(1)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
1089  }
1090  if(name == "RefTau"){
1091  (m_MET_CorrFinalTrk_Ref[type]).at(2)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
1092  (m_MET_CorrFinalClus_Ref[type]).at(2)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
1093  }
1094  if(name == "Muons"){
1095  (m_MET_CorrFinalTrk_Ref[type]).at(3)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
1096  (m_MET_CorrFinalClus_Ref[type]).at(3)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
1097  }
1098  if(name == "RefJet"){
1099  (m_MET_CorrFinalTrk_Ref[type]).at(4)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
1100  (m_MET_CorrFinalClus_Ref[type]).at(4)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
1101  }
1102  if(name == "PVSoftTrk"){
1103  (m_MET_CorrFinalTrk_Ref[type]).at(5)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
1104  }
1105  if(name == "SoftClus"){
1106  (m_MET_CorrFinalClus_Ref[type]).at(5)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
1107  }
1108  }
1109  }
1110 
1111  //Rebuilt
1112 
1113  for(const auto it : *met_Reb) {
1114  std::string name = it->name();
1115  if(name == "RefEle"){
1116  (m_MET_CorrFinalTrk_Reb[type]).at(0)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
1117  (m_MET_CorrFinalClus_Reb[type]).at(0)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
1118  }
1119  if(name == "RefGamma"){
1120  (m_MET_CorrFinalTrk_Reb[type]).at(1)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
1121  (m_MET_CorrFinalClus_Reb[type]).at(1)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
1122  }
1123  if(name == "RefTau"){
1124  (m_MET_CorrFinalTrk_Reb[type]).at(2)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
1125  (m_MET_CorrFinalClus_Reb[type]).at(2)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
1126  }
1127  if(name == "Muons"){
1128  (m_MET_CorrFinalTrk_Reb[type]).at(3)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
1129  (m_MET_CorrFinalClus_Reb[type]).at(3)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
1130  }
1131  if(name == "RefJet"){
1132  (m_MET_CorrFinalTrk_Reb[type]).at(4)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
1133  (m_MET_CorrFinalClus_Reb[type]).at(4)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
1134  }
1135  if(name == "PVSoftTrk"){
1136  (m_MET_CorrFinalTrk_Reb[type]).at(5)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
1137  }
1138  if(name == "SoftClus"){
1139  (m_MET_CorrFinalClus_Reb[type]).at(5)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
1140  }
1141  }
1142 
1143  // Fill Resolution
1144  if(m_doTruth){
1145  ATH_MSG_INFO( " Resolution:" );
1146  if(m_doMETRefPlots){
1147  (m_MET_Resolution_Ref[type]).at(0)->Fill(((*met_Ref)["FinalClus"]->mpx()-(*met_Truth)["NonInt"]->mpx())/1000., weight);
1148  (m_MET_Resolution_Ref[type]).at(1)->Fill(((*met_Ref)["FinalClus"]->mpy()-(*met_Truth)["NonInt"]->mpy())/1000., weight);
1149  (m_MET_Resolution_Ref[type]).at(2)->Fill(((*met_Ref)["FinalTrk"]->mpx()-(*met_Truth)["NonInt"]->mpx())/1000., weight);
1150  (m_MET_Resolution_Ref[type]).at(3)->Fill(((*met_Ref)["FinalTrk"]->mpy()-(*met_Truth)["NonInt"]->mpy())/1000., weight);
1151  }
1152  (m_MET_Resolution_Reb[type]).at(0)->Fill(((*met_Reb)["FinalClus"]->mpx()-(*met_Truth)["NonInt"]->mpx())/1000., weight);
1153  (m_MET_Resolution_Reb[type]).at(1)->Fill(((*met_Reb)["FinalClus"]->mpy()-(*met_Truth)["NonInt"]->mpy())/1000., weight);
1154  (m_MET_Resolution_Reb[type]).at(2)->Fill(((*met_Reb)["FinalTrk"]->mpx()-(*met_Truth)["NonInt"]->mpx())/1000., weight);
1155  (m_MET_Resolution_Reb[type]).at(3)->Fill(((*met_Reb)["FinalTrk"]->mpy()-(*met_Truth)["NonInt"]->mpy())/1000., weight);
1156  }
1157 
1158  //Fill MET significance
1159  if( (*met_Reb)["FinalClus"]->sumet() != 0) (m_MET_Significance_Reb[type]).at(0)->Fill((*met_Reb)["FinalClus"]->met()/sqrt((*met_Reb)["FinalClus"]->sumet()*1000.), weight);
1160  if( (*met_Reb)["FinalTrk"]->sumet() != 0) (m_MET_Significance_Reb[type]).at(1)->Fill((*met_Reb)["FinalTrk"]->met()/sqrt((*met_Reb)["FinalTrk"]->sumet()*1000.), weight);
1161 
1162  TLorentzVector target_tlv;
1163  if(m_doMETRefPlots){
1164  //Fill MET Significance
1165  ATH_MSG_INFO( " MET_significance:" );
1166  if( (*met_Ref)["FinalClus"]->sumet() != 0) (m_MET_Significance_Ref[type]).at(0)->Fill((*met_Ref)["FinalClus"]->met()/sqrt((*met_Ref)["FinalClus"]->sumet()*1000.), weight);
1167  if( (*met_Ref)["FinalTrk"]->sumet() != 0) (m_MET_Significance_Ref[type]).at(1)->Fill((*met_Ref)["FinalTrk"]->met()/sqrt((*met_Ref)["FinalTrk"]->sumet()*1000.), weight);
1168 
1169  //Fill Diff histograms
1170  for(const auto it : *met_Ref) {
1171  if(it->name() == "RefEle"){
1172  if(is_electron or (it->sumet() > 0)){
1173  target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
1174  (m_MET_Diff_Ref[type]).at(0)->Fill((target_tlv.Pt() - el_tlv.Pt())/1000., weight);
1175  (m_MET_Diff_Ref_x[type]).at(0)->Fill((target_tlv.Px() - el_tlv.Px())/1000., weight);
1176  (m_MET_Diff_Ref_y[type]).at(0)->Fill((target_tlv.Py() - el_tlv.Py())/1000., weight);
1177  (m_MET_Diff_Ref_phi[type]).at(0)->Fill(el_tlv.DeltaPhi(target_tlv), weight);
1178  (m_MET_Diff_Ref_sum[type]).at(0)->Fill((it->sumet() - sum_el)/1000., weight);
1179  }
1180  }
1181  if(it->name() == "RefGamma"){
1182  if(is_photon or (it->sumet() > 0)){
1183  target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
1184  (m_MET_Diff_Ref[type]).at(1)->Fill((target_tlv.Pt() - photon_tlv.Pt())/1000., weight);
1185  (m_MET_Diff_Ref_x[type]).at(1)->Fill((target_tlv.Px() - photon_tlv.Px())/1000., weight);
1186  (m_MET_Diff_Ref_y[type]).at(1)->Fill((target_tlv.Py() - photon_tlv.Py())/1000., weight);
1187  (m_MET_Diff_Ref_phi[type]).at(1)->Fill(photon_tlv.DeltaPhi(target_tlv), weight);
1188  (m_MET_Diff_Ref_sum[type]).at(1)->Fill((it->sumet() - sum_photon)/1000., weight);
1189  }
1190  }
1191  if(it->name() == "RefTau"){
1192  if(is_tau or (it->sumet() > 0)){
1193  target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
1194  (m_MET_Diff_Ref[type]).at(2)->Fill((target_tlv.Pt() - tau_tlv.Pt())/1000., weight);
1195  (m_MET_Diff_Ref_x[type]).at(2)->Fill((target_tlv.Px() - tau_tlv.Px())/1000., weight);
1196  (m_MET_Diff_Ref_y[type]).at(2)->Fill((target_tlv.Py() - tau_tlv.Py())/1000., weight);
1197  (m_MET_Diff_Ref_phi[type]).at(2)->Fill(tau_tlv.DeltaPhi(target_tlv), weight);
1198  (m_MET_Diff_Ref_sum[type]).at(2)->Fill((it->sumet() - sum_tau)/1000., weight);
1199  }
1200  }
1201  if(it->name() == "Muons"){
1202  if(is_muon or (it->sumet() > 0)){
1203  target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
1204  (m_MET_Diff_Ref[type]).at(3)->Fill((target_tlv.Pt() - mu_tlv.Pt())/1000., weight);
1205  (m_MET_Diff_Ref_x[type]).at(3)->Fill((target_tlv.Px() - mu_tlv.Px())/1000., weight);
1206  (m_MET_Diff_Ref_y[type]).at(3)->Fill((target_tlv.Py() - mu_tlv.Py())/1000., weight);
1207  (m_MET_Diff_Ref_phi[type]).at(3)->Fill(mu_tlv.DeltaPhi(target_tlv), weight);
1208  (m_MET_Diff_Ref_sum[type]).at(3)->Fill((it->sumet() - sum_mu)/1000., weight);
1209  }
1210  }
1211  if(it->name() == "RefJet"){
1212  if(is_jet or (it->sumet() > 0)){
1213  target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
1214  (m_MET_Diff_Ref[type]).at(4)->Fill((target_tlv.Pt() - jet_tlv.Pt())/1000., weight);
1215  (m_MET_Diff_Ref_x[type]).at(4)->Fill((target_tlv.Px() - jet_tlv.Px())/1000., weight);
1216  (m_MET_Diff_Ref_y[type]).at(4)->Fill((target_tlv.Py() - jet_tlv.Py())/1000., weight);
1217  (m_MET_Diff_Ref_phi[type]).at(4)->Fill(jet_tlv.DeltaPhi(target_tlv), weight);
1218  (m_MET_Diff_Ref_sum[type]).at(4)->Fill((it->sumet() - sum_jet)/1000., weight);
1219  }
1220  }
1221  }
1222  }
1223 
1224  // For rebuilt MET add only jets with pT>20e3 and JVT cut
1225  TLorentzVector jetReb_tlv;
1226  double sum_jetReb = 0;
1227  for(const auto jet : metJetsOR) {
1228  if(Accept(jet, JvtCut, jvtTool)) {
1229  jetReb_tlv += jet->p4();
1230  sum_jetReb += jet->pt();
1231  }
1232  }
1233 
1234  for(const auto it : *met_Reb) {
1235  if(it->name() == "RefEle"){
1236  if(is_electron or (it->sumet() > 0)){
1237  target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
1238  (m_MET_Diff_Reb[type]).at(0)->Fill((target_tlv.Pt() - el_tlv.Pt())/1000., weight);
1239  (m_MET_Diff_Reb_x[type]).at(0)->Fill((target_tlv.Px() - el_tlv.Px())/1000., weight);
1240  (m_MET_Diff_Reb_y[type]).at(0)->Fill((target_tlv.Py() - el_tlv.Py())/1000., weight);
1241  (m_MET_Diff_Reb_phi[type]).at(0)->Fill(el_tlv.DeltaPhi(target_tlv), weight);
1242  (m_MET_Diff_Reb_sum[type]).at(0)->Fill((it->sumet() - sum_el)/1000., weight);
1243  }
1244  }
1245  if(it->name() == "RefGamma"){
1246  if(is_photon or (it->sumet() > 0)){
1247  target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
1248  (m_MET_Diff_Reb[type]).at(1)->Fill((target_tlv.Pt() - photon_tlv.Pt())/1000., weight);
1249  (m_MET_Diff_Reb_x[type]).at(1)->Fill((target_tlv.Px() - photon_tlv.Px())/1000., weight);
1250  (m_MET_Diff_Reb_y[type]).at(1)->Fill((target_tlv.Py() - photon_tlv.Py())/1000., weight);
1251  (m_MET_Diff_Reb_phi[type]).at(1)->Fill(photon_tlv.DeltaPhi(target_tlv), weight);
1252  (m_MET_Diff_Reb_sum[type]).at(1)->Fill((it->sumet() - sum_photon)/1000., weight);
1253  }
1254  }
1255  if(it->name() == "RefTau"){
1256  if(is_tau or (it->sumet() > 0)){
1257  target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
1258  (m_MET_Diff_Reb[type]).at(2)->Fill((target_tlv.Pt() - tau_tlv.Pt())/1000., weight);
1259  (m_MET_Diff_Reb_x[type]).at(2)->Fill((target_tlv.Px() - tau_tlv.Px())/1000., weight);
1260  (m_MET_Diff_Reb_y[type]).at(2)->Fill((target_tlv.Py() - tau_tlv.Py())/1000., weight);
1261  (m_MET_Diff_Reb_phi[type]).at(2)->Fill(tau_tlv.DeltaPhi(target_tlv), weight);
1262  (m_MET_Diff_Reb_sum[type]).at(2)->Fill((it->sumet() - sum_tau)/1000., weight);
1263  }
1264  }
1265  if(it->name() == "Muons"){
1266  if(is_muon or (it->sumet() > 0)){
1267  target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
1268  (m_MET_Diff_Reb[type]).at(3)->Fill((target_tlv.Pt() - mu_tlv.Pt())/1000., weight);
1269  (m_MET_Diff_Reb_x[type]).at(3)->Fill((target_tlv.Px() - mu_tlv.Px())/1000., weight);
1270  (m_MET_Diff_Reb_y[type]).at(3)->Fill((target_tlv.Py() - mu_tlv.Py())/1000., weight);
1271  (m_MET_Diff_Reb_phi[type]).at(3)->Fill(mu_tlv.DeltaPhi(target_tlv), weight);
1272  (m_MET_Diff_Reb_sum[type]).at(3)->Fill((it->sumet() - sum_mu)/1000., weight);
1273  }
1274  }
1275  if(it->name() == "RefJet"){
1276  if(is_jet or (it->sumet() > 0)){
1277  target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
1278  (m_MET_Diff_Reb[type]).at(4)->Fill((target_tlv.Pt() - jetReb_tlv.Pt())/1000., weight);
1279  (m_MET_Diff_Reb_x[type]).at(4)->Fill((target_tlv.Px() - jetReb_tlv.Px())/1000., weight);
1280  (m_MET_Diff_Reb_y[type]).at(4)->Fill((target_tlv.Py() - jetReb_tlv.Py())/1000., weight);
1281  (m_MET_Diff_Reb_phi[type]).at(4)->Fill(jetReb_tlv.DeltaPhi(target_tlv), weight);
1282  (m_MET_Diff_Reb_sum[type]).at(4)->Fill((it->sumet() - sum_jetReb)/1000., weight);
1283  }
1284  }
1285  }
1286 
1287  if(type == "AntiKt4EMTopo") {
1288  //Calo MET
1289  //const xAOD::JetContainer* emptyjets = 0;
1290  ConstDataVector<JetContainer> metJetsEmpty(SG::VIEW_ELEMENTS);
1291  MissingETContainer* met_Calo = new MissingETContainer();
1292  if( evtStore()->record(met_Calo,("MET_Calo"+type).c_str()).isFailure() ) {
1293  ATH_MSG_WARNING("Unable to record MissingETContainer: MET_Calo_" << type);
1294  return StatusCode::FAILURE;
1295  }
1296  MissingETAuxContainer* met_CaloAux = new MissingETAuxContainer();
1297  if( evtStore()->record(met_CaloAux,("MET_Calo"+type+"Aux").c_str()).isFailure() ) {
1298  ATH_MSG_WARNING("Unable to record MissingETAuxContainer: MET_Calo" << type);
1299  return StatusCode::FAILURE;
1300  }
1301  met_Calo->setStore(met_CaloAux);
1302  MissingETAssociationHelper metHelper(metMap);
1303  if( (*m_metmaker)->rebuildJetMET("RefJet", "SoftClus", "PVSoftTrk", met_Calo, metJetsEmpty.asDataVector(), coreMet, metHelper, true).isFailure() ) {
1304  ATH_MSG_WARNING("Failed to build jet and soft terms.");
1305  }
1306 
1307  if((*met_Calo)["SoftClus"]) clsource = (*met_Calo)["SoftClus"]->source();
1308  if( met::buildMETSum("FinalClus", met_Calo, clsource).isFailure() ) {
1309  ATH_MSG_WARNING("Building MET FinalClus sum failed.");
1310  }
1311 
1312  m_MET_Calo->Fill((*met_Calo)["FinalClus"]->met()/1000., weight);
1313  m_MET_Calo_x->Fill((*met_Calo)["FinalClus"]->mpx()/1000., weight);
1314  m_MET_Calo_y->Fill((*met_Calo)["FinalClus"]->mpy()/1000., weight);
1315  m_MET_Calo_phi->Fill((*met_Calo)["FinalClus"]->phi(), weight);
1316  m_MET_Calo_sum->Fill((*met_Calo)["FinalClus"]->sumet()/1000., weight);
1317 
1318  }
1319 
1320  }
1321 
1322  //Currently we don't store MET_Track in the derivations
1323  //if MET_Ref not present, then we also dont have MET_Track
1324  if(m_doMETRefPlots){
1325 
1326  //Retrieve MET Track
1327  const xAOD::MissingETContainer* met_Track = nullptr;
1328  ATH_CHECK( evtStore()->retrieve(met_Track,"MET_Track") );
1329  if (!met_Track) {
1330  ATH_MSG_ERROR ( "Failed to retrieve MET_Track. Exiting." );
1331  return StatusCode::FAILURE;
1332  }
1333 
1334  // Fill MET Track
1335  ATH_MSG_INFO( " MET_Track:" );
1336 
1337  m_MET_Track->Fill((*met_Track)["Track"]->met()/1000., weight);
1338  m_MET_Track_x->Fill((*met_Track)["Track"]->mpx()/1000., weight);
1339  m_MET_Track_y->Fill((*met_Track)["Track"]->mpy()/1000., weight);
1340  m_MET_Track_phi->Fill((*met_Track)["Track"]->phi(), weight);
1341  m_MET_Track_sum->Fill((*met_Track)["Track"]->sumet()/1000., weight);
1342 
1343  const xAOD::VertexContainer *vxCont = nullptr;
1344  ATH_CHECK( evtStore()->retrieve(vxCont, "PrimaryVertices") );
1345  for(const auto vx : *vxCont) {
1346  int N = vx->index();
1347  const std::string name = "PVTrack_vx"+std::to_string(N);
1348  if(vx->vertexType()!=xAOD::VxType::NoVtx) {
1349  if(vx->vertexType()==xAOD::VxType::PriVtx) {
1350  m_MET_PVTrack_Nominal->Fill((*met_Track)[name]->met()/1000., weight);
1351  m_MET_PVTrack_Nominal_x->Fill((*met_Track)[name]->mpx()/1000., weight);
1352  m_MET_PVTrack_Nominal_y->Fill((*met_Track)[name]->mpy()/1000., weight);
1353  m_MET_PVTrack_Nominal_phi->Fill((*met_Track)[name]->phi(), weight);
1354  m_MET_PVTrack_Nominal_sum->Fill((*met_Track)[name]->sumet()/1000., weight);
1355  } else {
1356  m_MET_PVTrack_Pileup->Fill((*met_Track)[name]->met()/1000., weight);
1357  m_MET_PVTrack_Pileup_x->Fill((*met_Track)[name]->mpx()/1000., weight);
1358  m_MET_PVTrack_Pileup_y->Fill((*met_Track)[name]->mpy()/1000., weight);
1359  m_MET_PVTrack_Pileup_phi->Fill((*met_Track)[name]->phi(), weight);
1360  m_MET_PVTrack_Pileup_sum->Fill((*met_Track)[name]->sumet()/1000., weight);
1361  }
1362  }
1363  }
1364  }
1365 
1366  return StatusCode::SUCCESS;
1367  //return StatusCode::FAILURE;
1368  }
1369 
1370  StatusCode PhysValMET::procHistograms()
1371  {
1372  ATH_MSG_INFO ("Finalising hists " << name() << "...");
1373 
1374  for (const auto& type : m_types){
1375  for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_Reb[type]).size(); ++i) {
1376  if (m_doMETRefPlots){
1377  (m_MET_Ref[type]).at(i)->Sumw2();
1378  (m_MET_Ref_x[type]).at(i)->Sumw2();
1379  (m_MET_Ref_y[type]).at(i)->Sumw2();
1380  (m_MET_Ref_phi[type]).at(i)->Sumw2();
1381  (m_MET_Ref_sum[type]).at(i)->Sumw2();
1382  }
1383  (m_MET_Reb[type]).at(i)->Sumw2();
1384  (m_MET_Reb_x[type]).at(i)->Sumw2();
1385  (m_MET_Reb_y[type]).at(i)->Sumw2();
1386  (m_MET_Reb_phi[type]).at(i)->Sumw2();
1387  (m_MET_Reb_sum[type]).at(i)->Sumw2();
1388  }
1389 
1390  for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_Diff_Reb[type]).size(); ++i) {
1391  if (m_doMETRefPlots){
1392  (m_MET_Diff_Ref[type]).at(i)->Sumw2();
1393  (m_MET_Diff_Ref_x[type]).at(i)->Sumw2();
1394  (m_MET_Diff_Ref_y[type]).at(i)->Sumw2();
1395  (m_MET_Diff_Ref_phi[type]).at(i)->Sumw2();
1396  (m_MET_Diff_Ref_sum[type]).at(i)->Sumw2();
1397  }
1398  (m_MET_Diff_Reb[type]).at(i)->Sumw2();
1399  (m_MET_Diff_Reb_x[type]).at(i)->Sumw2();
1400  (m_MET_Diff_Reb_y[type]).at(i)->Sumw2();
1401  (m_MET_Diff_Reb_phi[type]).at(i)->Sumw2();
1402  (m_MET_Diff_Reb_sum[type]).at(i)->Sumw2();
1403  }
1404 
1405  for(std::vector<TH2D*>::size_type i = 0; i < (m_MET_CorrFinalTrk_Reb[type]).size(); ++i) {
1406  if (m_doMETRefPlots){
1407  (m_MET_CorrFinalTrk_Ref[type]).at(i)->Sumw2();
1408  }
1409  (m_MET_CorrFinalTrk_Reb[type]).at(i)->Sumw2();
1410  }
1411 
1412  for(std::vector<TH2D*>::size_type i = 0; i < (m_MET_CorrFinalClus_Reb[type]).size(); ++i) {
1413  if (m_doMETRefPlots){
1414  (m_MET_CorrFinalClus_Ref[type]).at(i)->Sumw2();
1415  }
1416  (m_MET_CorrFinalClus_Reb[type]).at(i)->Sumw2();
1417  }
1418 
1419  for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_Significance_Reb[type]).size(); ++i) {
1420  if (m_doMETRefPlots){
1421  (m_MET_Significance_Ref[type]).at(i)->Sumw2();
1422  }
1423  (m_MET_Significance_Reb[type]).at(i)->Sumw2();
1424  }
1425 
1426  for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_Resolution_Reb[type]).size(); ++i) {
1427  if (m_doMETRefPlots){
1428  (m_MET_Resolution_Ref[type]).at(i)->Sumw2();
1429  }
1430  (m_MET_Resolution_Reb[type]).at(i)->Sumw2();
1431  }
1432 
1433  for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_dPhi_Ref[type]).size(); ++i) {
1434  if (m_doMETRefPlots){
1435  (m_MET_dPhi_Ref[type]).at(i)->Sumw2();
1436  }
1437  (m_MET_dPhi_Reb[type]).at(i)->Sumw2();
1438  }
1439 
1440  int nBins = (m_MET_Reb[type]).at(7)->GetNbinsX();
1441  for(int i=1;i<=nBins;i++){
1442  double err;
1443  if (m_doMETRefPlots){
1444  (m_MET_Cumu_Ref[type]).at(0)->SetBinContent(i, (m_MET_Ref[type]).at(8)->IntegralAndError(i,nBins+1,err));
1445  (m_MET_Cumu_Ref[type]).at(0)->SetBinError(i, err);
1446  (m_MET_Cumu_Ref[type]).at(1)->SetBinContent(i, (m_MET_Ref[type]).at(7)->IntegralAndError(i,nBins+1,err));
1447  (m_MET_Cumu_Ref[type]).at(1)->SetBinError(i, err);
1448  }
1449  (m_MET_Cumu_Reb[type]).at(0)->SetBinContent(i, (m_MET_Reb[type]).at(8)->IntegralAndError(i,nBins+1,err));
1450  (m_MET_Cumu_Reb[type]).at(0)->SetBinError(i, err);
1451  (m_MET_Cumu_Reb[type]).at(1)->SetBinContent(i, (m_MET_Reb[type]).at(7)->IntegralAndError(i,nBins+1,err));
1452  (m_MET_Cumu_Reb[type]).at(1)->SetBinError(i, err);
1453  }
1454  for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_Cumu_Ref[type]).size(); ++i) {
1455  if (m_doMETRefPlots){
1456  m_MET_Cumu_Ref[type].at(i)->Scale(1./(m_MET_Cumu_Ref[type]).at(i)->GetBinContent(1));
1457  }
1458  m_MET_Cumu_Reb[type].at(i)->Scale(1./(m_MET_Cumu_Reb[type]).at(i)->GetBinContent(1));
1459  }
1460 
1461  }
1462 
1463  if (m_doMETRefPlots){
1464  m_MET_Track->Sumw2();
1465  m_MET_Track_x->Sumw2();
1466  m_MET_Track_y->Sumw2();
1467  m_MET_Track_phi->Sumw2();
1468  m_MET_Track_sum->Sumw2();
1469  m_MET_PVTrack_Nominal->Sumw2();
1470  m_MET_PVTrack_Nominal_x->Sumw2();
1471  m_MET_PVTrack_Nominal_y->Sumw2();
1472  m_MET_PVTrack_Nominal_phi->Sumw2();
1473  m_MET_PVTrack_Nominal_sum->Sumw2();
1474  m_MET_PVTrack_Pileup->Sumw2();
1475  m_MET_PVTrack_Pileup_x->Sumw2();
1476  m_MET_PVTrack_Pileup_y->Sumw2();
1477  m_MET_PVTrack_Pileup_phi->Sumw2();
1478  m_MET_PVTrack_Pileup_sum->Sumw2();
1479  }
1480 
1481  m_MET_Calo->Sumw2();
1482  m_MET_Calo_x->Sumw2();
1483  m_MET_Calo_y->Sumw2();
1484  m_MET_Calo_phi->Sumw2();
1485  m_MET_Calo_sum->Sumw2();
1486 
1487  return StatusCode::SUCCESS;
1488  }
1489 
1491  // Const methods:
1493 
1495  // Non-const methods:
1497  bool PhysValMET::Accept(const xAOD::Muon* mu)
1498  {
1499  if( mu->pt()<2.5e3 || mu->pt()/cosh(mu->eta())<4e3 ) return false;
1500  return static_cast<bool> (m_muonSelTool->accept(*mu));
1501  }
1502 
1503  bool PhysValMET::Accept(const xAOD::Electron* el)
1504  {
1505  if( fabs(el->eta())>2.47 || el->pt()<10e3 ) return false;
1506  return static_cast<bool> (m_elecSelLHTool->accept(el));
1507  }
1508 
1509  bool PhysValMET::Accept(const xAOD::Photon* ph)
1510  {
1511  if( !(ph->author()&20) || fabs(ph->eta())>2.47 || ph->pt()<10e3 ) return false;
1512  return static_cast<bool>(m_photonSelIsEMTool->accept(ph));
1513  }
1514 
1515  bool PhysValMET::Accept(const xAOD::TauJet* tau)
1516  { return static_cast<bool> (m_tauSelTool->accept( *tau )); }
1517 
1518  bool PhysValMET::Accept(const xAOD::Jet* jet, double JvtCut, ToolHandle<IJetUpdateJvt>* jvtTool)
1519  {
1520  if( jet->pt()<20e3 || jvtTool == nullptr) return false;
1521  return (fabs(jet->eta()) > 2.4 || jet->pt() > 60e3 || (*jvtTool)->updateJvt(*jet) > JvtCut);
1522  }
1523 
1525  // Protected methods:
1527 
1529  // Const methods:
1531 
1533  // Non-const methods:
1535 
1536 
1537 }
1538 
1539 // LocalWords: str
MissingEtDQA::PhysValMET::m_MET_Reb_phi
std::map< std::string, std::vector< TH1D * > > m_MET_Reb_phi
Definition: PhysValMET.h:139
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
MissingEtDQA::PhysValMET::m_MET_PVTrack_Nominal_phi
TH1D * m_MET_PVTrack_Nominal_phi
Definition: PhysValMET.h:115
MissingEtDQA::PhysValMET::initialize
virtual StatusCode initialize()
Definition: PhysValMET.cxx:115
MissingEtDQA::PhysValMET::m_MET_Diff_Reb
std::map< std::string, std::vector< TH1D * > > m_MET_Diff_Reb
Definition: PhysValMET.h:141
MissingETContainer
Definition: Reconstruction/MissingETEvent/MissingETEvent/MissingETContainer.h:22
xAOD::name
name
Definition: TriggerMenuJson_v1.cxx:29
MissingEtDQA::PhysValMET::~PhysValMET
virtual ~PhysValMET()
Destructor:
Definition: PhysValMET.cxx:74
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
MissingEtDQA::PhysValMET::m_MET_Track_y
TH1D * m_MET_Track_y
Definition: PhysValMET.h:114
xAOD::MissingETAuxContainer
MissingETAuxContainer_v1 MissingETAuxContainer
Definition: MissingETAuxContainer.h:16
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
AthCheckMacros.h
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
MissingEtDQA::PhysValMET::m_muonColl
std::string m_muonColl
Definition: PhysValMET.h:93
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:73
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
ConstDataVector::end
iterator end() noexcept
Return an iterator pointing past the end of the collection.
MissingEtDQA::PhysValMET::m_MET_Calo_sum
TH1D * m_MET_Calo_sum
Definition: PhysValMET.h:117
MissingEtDQA::PhysValMET::m_MET_Track
TH1D * m_MET_Track
Definition: PhysValMET.h:114
MissingEtDQA::PhysValMET::m_eleColl
std::string m_eleColl
Definition: PhysValMET.h:90
MissingEtDQA::PhysValMET::m_tauColl
std::string m_tauColl
Definition: PhysValMET.h:92
MissingEtDQA::PhysValMET::bookHistograms
virtual StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition: PhysValMET.cxx:195
MissingEtDQA::PhysValMET::m_elecSelLHTool
ToolHandle< IAsgElectronLikelihoodTool > m_elecSelLHTool
Definition: PhysValMET.h:156
MissingEtDQA::PhysValMET::m_corename
std::string m_corename
Definition: PhysValMET.h:95
MissingEtDQA::PhysValMET::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: PhysValMET.cxx:566
xAOD::Egamma_v1::author
uint16_t author(uint16_t bitmask=EgammaParameters::AuthorALL) const
Get author.
Definition: Egamma_v1.cxx:166
skel.it
it
Definition: skel.GENtoEVGEN.py:407
M_PI
#define M_PI
Definition: ActiveFraction.h:11
defineDB.jets
jets
Definition: JetTagCalibration/share/defineDB.py:24
xAOD
ICaloAffectedTool is abstract interface for tools checking if 4 mom is in calo affected region.
Definition: ICaloAffectedTool.h:24
MissingEtDQA
Definition: PhysValMET.cxx:46
xAOD::MissingETContainer
MissingETContainer_v1 MissingETContainer
Definition: Event/xAOD/xAODMissingET/xAODMissingET/MissingETContainer.h:16
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
MuonR4::to_string
std::string to_string(const SectorProjector proj)
Definition: MsTrackSeeder.cxx:74
MissingETBase::Types::bitmask_t
uint64_t bitmask_t
Type for status word bit mask.
Definition: MissingETBase.h:39
MissingEtDQA::PhysValMET::m_MET_Diff_Reb_y
std::map< std::string, std::vector< TH1D * > > m_MET_Diff_Reb_y
Definition: PhysValMET.h:143
MissingETBase::Source::Signal::EMTopo
@ EMTopo
Indicator for MET contribution from TopoClusters with EM (basic signal) calibration applied.
MissingEtDQA::PhysValMET::m_metmakerTopo
ToolHandle< IMETMaker > m_metmakerTopo
Definition: PhysValMET.h:160
xAOD::VxType::NoVtx
@ NoVtx
Dummy vertex. TrackParticle was not used in vertex fit.
Definition: TrackingPrimitives.h:571
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
MissingEtDQA::PhysValMET::m_MET_CorrFinalClus_Reb
std::map< std::string, std::vector< TH2D * > > m_MET_CorrFinalClus_Reb
Definition: PhysValMET.h:151
MissingEtDQA::PhysValMET::m_names
std::map< std::string, std::string > m_names
Definition: PhysValMET.h:111
MissingEtDQA::PhysValMET::m_terms
std::vector< std::string > m_terms
Definition: PhysValMET.h:108
xAOD::MissingETAssociationMap_v1
Definition: MissingETAssociationMap_v1.h:29
ConstDataVector::asDataVector
const DV * asDataVector() const
Return a pointer to this object, as a const DataVector.
MissingEtDQA::PhysValMET::m_MET_dPhi_Ref
std::map< std::string, std::vector< TH1D * > > m_MET_dPhi_Ref
Definition: PhysValMET.h:133
MissingEtDQA::PhysValMET::m_MET_PVTrack_Pileup_y
TH1D * m_MET_PVTrack_Pileup_y
Definition: PhysValMET.h:116
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:190
MissingEtDQA::PhysValMET::m_MET_PVTrack_Pileup
TH1D * m_MET_PVTrack_Pileup
Definition: PhysValMET.h:116
met::buildMETSum
StatusCode buildMETSum(const std::string &totalName, xAOD::MissingETContainer *metCont)
Definition: METHelpers.cxx:64
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
MissingEtDQA::PhysValMET::m_MET_PVTrack_Pileup_x
TH1D * m_MET_PVTrack_Pileup_x
Definition: PhysValMET.h:116
MissingEtDQA::PhysValMET::m_doTruth
bool m_doTruth
Definition: PhysValMET.h:82
METHelpers.h
MissingEtDQA::PhysValMET::m_MET_Ref_phi
std::map< std::string, std::vector< TH1D * > > m_MET_Ref_phi
Definition: PhysValMET.h:123
met
Definition: IMETSignificance.h:24
MissingEtDQA::PhysValMET::m_MET_Track_sum
TH1D * m_MET_Track_sum
Definition: PhysValMET.h:114
MissingEtDQA::PhysValMET::m_MET_Diff_Reb_x
std::map< std::string, std::vector< TH1D * > > m_MET_Diff_Reb_x
Definition: PhysValMET.h:142
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
MissingETBase::Source::Signal::UnknownSignal
@ UnknownSignal
Unknown signal contribution.
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:616
MissingEtDQA::PhysValMET::m_gammaColl
std::string m_gammaColl
Definition: PhysValMET.h:91
SG::Decorator< float >
ElectronContainer.h
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:183
DataModel_detail::iterator
(Non-const) Iterator class for DataVector/DataList.
Definition: DVLIterator.h:184
MissingEtDQA::PhysValMET::m_MET_PVTrack_Nominal
TH1D * m_MET_PVTrack_Nominal
Definition: PhysValMET.h:115
MissingEtDQA::PhysValMET::m_MET_Reb_y
std::map< std::string, std::vector< TH1D * > > m_MET_Reb_y
Definition: PhysValMET.h:138
lumiFormat.i
int i
Definition: lumiFormat.py:85
MissingEtDQA::PhysValMET::m_metmakerPFlow
ToolHandle< IMETMaker > m_metmakerPFlow
Definition: PhysValMET.h:161
MissingEtDQA::PhysValMET::m_jvtToolPFlow
ToolHandle< IJetUpdateJvt > m_jvtToolPFlow
Definition: PhysValMET.h:159
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
MissingETAuxContainer.h
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
MissingEtDQA::PhysValMET::m_MET_Significance_Ref
std::map< std::string, std::vector< TH1D * > > m_MET_Significance_Ref
Definition: PhysValMET.h:132
MissingEtDQA::PhysValMET::m_MET_Calo_x
TH1D * m_MET_Calo_x
Definition: PhysValMET.h:117
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
MissingEtDQA::PhysValMET::m_MET_Resolution_Reb
std::map< std::string, std::vector< TH1D * > > m_MET_Resolution_Reb
Definition: PhysValMET.h:147
test_pyathena.parent
parent
Definition: test_pyathena.py:15
MissingEtDQA::PhysValMET::m_MET_Resolution_Ref
std::map< std::string, std::vector< TH1D * > > m_MET_Resolution_Ref
Definition: PhysValMET.h:131
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::MissingETAuxContainer_v1
Auxiliary data store for xAOD::MissingETContainer.
Definition: MissingETAuxContainer_v1.h:20
MissingEtDQA::PhysValMET::m_muonSelTool
ToolHandle< CP::IMuonSelectionTool > m_muonSelTool
Definition: PhysValMET.h:155
python.getProblemFolderFromLogs.el
dictionary el
Definition: getProblemFolderFromLogs.py:48
MissingEtDQA::PhysValMET::m_mapname
std::string m_mapname
Definition: PhysValMET.h:94
MissingEtDQA::PhysValMET::m_MET_dPhi_Reb
std::map< std::string, std::vector< TH1D * > > m_MET_dPhi_Reb
Definition: PhysValMET.h:149
MissingEtDQA::PhysValMET::m_MET_PVTrack_Pileup_sum
TH1D * m_MET_PVTrack_Pileup_sum
Definition: PhysValMET.h:116
TauJetContainer.h
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
Vertex.h
AcceptData.h
MissingETBase.h
beamspotman.dir
string dir
Definition: beamspotman.py:619
MissingEtDQA::PhysValMET::m_MET_Ref
std::map< std::string, std::vector< TH1D * > > m_MET_Ref
Definition: PhysValMET.h:120
MissingEtDQA::PhysValMET::m_MET_PVTrack_Nominal_x
TH1D * m_MET_PVTrack_Nominal_x
Definition: PhysValMET.h:115
MissingEtDQA::PhysValMET::m_MET_Significance_Reb
std::map< std::string, std::vector< TH1D * > > m_MET_Significance_Reb
Definition: PhysValMET.h:148
dumpTgcDigiJitter.nBins
list nBins
Definition: dumpTgcDigiJitter.py:29
xAOD::MissingETContainer_v1
Container for xAOD::MissingET_v1 objects.
Definition: MissingETContainer_v1.h:21
MissingET.h
MissingEtDQA::PhysValMET::m_MET_Reb_x
std::map< std::string, std::vector< TH1D * > > m_MET_Reb_x
Definition: PhysValMET.h:137
MissingEtDQA::PhysValMET::m_MET_Diff_Reb_sum
std::map< std::string, std::vector< TH1D * > > m_MET_Diff_Reb_sum
Definition: PhysValMET.h:145
remainder
std::vector< std::string > remainder(const std::vector< std::string > &v1, const std::vector< std::string > &v2)
Definition: compareFlatTrees.cxx:44
MissingEtDQA::PhysValMET::m_MET_Track_phi
TH1D * m_MET_Track_phi
Definition: PhysValMET.h:114
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
MissingEtDQA::PhysValMET::m_MET_Diff_Reb_phi
std::map< std::string, std::vector< TH1D * > > m_MET_Diff_Reb_phi
Definition: PhysValMET.h:144
MissingEtDQA::PhysValMET::m_dir_met
std::vector< std::string > m_dir_met
Definition: PhysValMET.h:153
MissingEtDQA::PhysValMET::m_MET_Cumu_Reb
std::map< std::string, std::vector< TH1D * > > m_MET_Cumu_Reb
Definition: PhysValMET.h:146
ConstDataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
MissingEtDQA::PhysValMET::m_MET_Cumu_Ref
std::map< std::string, std::vector< TH1D * > > m_MET_Cumu_Ref
Definition: PhysValMET.h:130
MissingEtDQA::PhysValMET::m_jvtToolEM
ToolHandle< IJetUpdateJvt > m_jvtToolEM
Definition: PhysValMET.h:158
MissingEtDQA::PhysValMET::m_metmaker
ToolHandle< IMETMaker > * m_metmaker
Definition: PhysValMET.h:163
MissingEtDQA::PhysValMET::m_MET_Calo
TH1D * m_MET_Calo
Definition: PhysValMET.h:117
xAOD::MissingETAssociationHelper
Definition: MissingETAssociationHelper.h:22
MissingEtDQA::PhysValMET::m_photonSelIsEMTool
ToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEMTool
Definition: PhysValMET.h:157
xAOD::Electron_v1
Definition: Electron_v1.h:34
MissingEtDQA::PhysValMET::m_MET_Ref_sum
std::map< std::string, std::vector< TH1D * > > m_MET_Ref_sum
Definition: PhysValMET.h:124
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
MuonContainer.h
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
Muon
struct TBPatternUnitContext Muon
TrackParticle.h
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
MissingEtDQA::PhysValMET::m_MET_Reb
std::map< std::string, std::vector< TH1D * > > m_MET_Reb
Definition: PhysValMET.h:136
MissingETBase::Source::Signal::Track
@ Track
Indicator for MET contribution from reconstructed charged particle tracks.
VertexContainer.h
PhysValMET.h
JetContainer.h
xAOD::Photon_v1
Definition: Photon_v1.h:37
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ConstDataVector
DataVector adapter that acts like it holds const pointers.
Definition: ConstDataVector.h:76
MissingEtDQA::PhysValMET::m_MET_Diff_Ref
std::map< std::string, std::vector< TH1D * > > m_MET_Diff_Ref
Definition: PhysValMET.h:125
MissingEtDQA::PhysValMET::m_MET_Ref_x
std::map< std::string, std::vector< TH1D * > > m_MET_Ref_x
Definition: PhysValMET.h:121
MissingEtDQA::PhysValMET::m_MET_Diff_Ref_phi
std::map< std::string, std::vector< TH1D * > > m_MET_Diff_Ref_phi
Definition: PhysValMET.h:128
MissingEtDQA::PhysValMET::m_MET_Track_x
TH1D * m_MET_Track_x
Definition: PhysValMET.h:114
ManagedMonitorToolBase::all
@ all
Definition: ManagedMonitorToolBase.h:115
MissingEtDQA::PhysValMET::m_tauSelTool
ToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelTool
Definition: PhysValMET.h:162
MissingEtDQA::PhysValMET::m_types
std::vector< std::string > m_types
Definition: PhysValMET.h:105
xAOD::Egamma_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: Egamma_v1.cxx:65
xAODType::Tau
@ Tau
The object is a tau (jet)
Definition: ObjectType.h:49
MissingEtDQA::PhysValMET::m_MET_CorrFinalTrk_Reb
std::map< std::string, std::vector< TH2D * > > m_MET_CorrFinalTrk_Reb
Definition: PhysValMET.h:150
xAOD::Egamma_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: Egamma_v1.cxx:70
MissingEtDQA::PhysValMET::m_MET_CorrFinalTrk_Ref
std::map< std::string, std::vector< TH2D * > > m_MET_CorrFinalTrk_Ref
Definition: PhysValMET.h:134
MissingETAssociationMap.h
ManagedMonitorToolBase::m_detailLevel
unsigned int m_detailLevel
Definition: ManagedMonitorToolBase.h:836
MissingEtDQA::PhysValMET::m_MET_CorrFinalClus_Ref
std::map< std::string, std::vector< TH2D * > > m_MET_CorrFinalClus_Ref
Definition: PhysValMET.h:135
MissingEtDQA::PhysValMET::m_MET_Calo_phi
TH1D * m_MET_Calo_phi
Definition: PhysValMET.h:117
MissingEtDQA::PhysValMET::m_doMETRefPlots
bool m_doMETRefPlots
Definition: PhysValMET.h:84
Accept
Templated class containing a cut, name of cut and description of cut(optional) Typically,...
Definition: CutFlow.h:28
MissingEtDQA::PhysValMET::m_MET_PVTrack_Nominal_y
TH1D * m_MET_PVTrack_Nominal_y
Definition: PhysValMET.h:115
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:51
passOR
@ passOR
Definition: SUSYToolsTester.cxx:100
MissingEtDQA::PhysValMET::m_MET_PVTrack_Nominal_sum
TH1D * m_MET_PVTrack_Nominal_sum
Definition: PhysValMET.h:115
MissingEtDQA::PhysValMET::m_MET_Diff_Ref_sum
std::map< std::string, std::vector< TH1D * > > m_MET_Diff_Ref_sum
Definition: PhysValMET.h:129
MissingEtDQA::PhysValMET::m_MET_Reb_sum
std::map< std::string, std::vector< TH1D * > > m_MET_Reb_sum
Definition: PhysValMET.h:140
MissingEtDQA::PhysValMET::m_MET_Calo_y
TH1D * m_MET_Calo_y
Definition: PhysValMET.h:117
MissingETAssociationHelper.h
Decorator.h
Helper class to provide type-safe access to aux data.
PhotonContainer.h
ConstDataVector::begin
iterator begin() noexcept
Return an iterator pointing at the beginning of the collection.
MissingETComposition.h
MissingETContainer.h
MissingEtDQA::PhysValMET::Accept
bool Accept(const xAOD::Electron *el)
Definition: PhysValMET.cxx:1503
xAOD::EventInfo_v1::beamSpotWeight
float beamSpotWeight() const
Weight for beam spot size reweighting.
Definition: EventInfo_v1.cxx:970
ManagedMonitorToolBase::regHist
virtual StatusCode regHist(TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition: ManagedMonitorToolBase.cxx:1344
MissingEtDQA::PhysValMET::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: PhysValMET.cxx:1370
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
MissingEtDQA::PhysValMET::m_MET_Diff_Ref_x
std::map< std::string, std::vector< TH1D * > > m_MET_Diff_Ref_x
Definition: PhysValMET.h:126
MissingEtDQA::PhysValMET::m_MET_Diff_Ref_y
std::map< std::string, std::vector< TH1D * > > m_MET_Diff_Ref_y
Definition: PhysValMET.h:127
MissingEtDQA::PhysValMET::m_inputIsDAOD
bool m_inputIsDAOD
Definition: PhysValMET.h:83
MissingEtDQA::PhysValMET::m_MET_PVTrack_Pileup_phi
TH1D * m_MET_PVTrack_Pileup_phi
Definition: PhysValMET.h:116
MissingEtDQA::PhysValMET::m_MET_Ref_y
std::map< std::string, std::vector< TH1D * > > m_MET_Ref_y
Definition: PhysValMET.h:122
Generated on Thu Oct 30 2025 21:16:06 for ATLAS Offline Software by   doxygen 1.8.18