ATLAS Offline Software
IDPerfMonWenu.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // **********************************************************************
6 // IDPerfMonWenu.cxx
7 // AUTHORS: Beate Heinemann, Tobias Golling, Sara Strandberg
8 // **********************************************************************
9 
10 #include <cmath>
11 #include "TH1.h"
12 #include "TH2.h"
13 #include "TH1F.h"
14 #include "TH2F.h"
15 #include "TProfile.h"
16 //#include "TMath.h"
17 #include "TLorentzVector.h"
18 
19 #include "StoreGate/StoreGateSvc.h"
20 
21 #include "IdDictDetDescr/IdDictManager.h"
22 #include "InDetIdentifier/PixelID.h"
23 #include "InDetIdentifier/SCT_ID.h"
24 #include "InDetIdentifier/TRT_ID.h"
25 #include "TRT_ReadoutGeometry/TRT_DetectorManager.h"
26 
27 #include "TrkTrack/TrackCollection.h"
28 #include "InDetRIO_OnTrack/SiClusterOnTrack.h"
29 #include "InDetPrepRawData/SiCluster.h"
30 
31 #include "TrkEventPrimitives/FitQuality.h"
32 #include "TrkEventPrimitives/LocalParameters.h"
33 
34 #include "egammaEvent/egammaParamDefs.h"
35 #include "egammaEvent/egammaPIDdefsObs.h"
36 
37 #include "xAODEgamma/Electron.h"
38 #include "xAODEgamma/Egamma.h"
39 #include "xAODEgamma/Photon.h"
40 #include "xAODCaloEvent/CaloCluster.h"
41 
42 #include "xAODMissingET/MissingET.h"
43 #include "xAODMissingET/MissingETContainer.h"
44 
45 #include "AthenaMonitoring/AthenaMonManager.h"
46 #include "InDetPerformanceMonitoring/IDPerfMonWenu.h"
47 
48 #include "GaudiKernel/SystemOfUnits.h"
49 #include "GaudiKernel/PhysicalConstants.h"
50 
51 #include <stdexcept>
52 
53 // *********************************************************************
54 // Public Methods
55 // *********************************************************************
56 
57 namespace{
58 template <class T>
59  const T *
60  getCollectionWithCheck(const ServiceHandle<StoreGateSvc> & evtStore,const std::string &contName){
61  const T * container{};
62  if (evtStore->contains<T>(contName)){
63  //retrieve
64  if(evtStore->retrieve(container,contName).isFailure()) return nullptr;
65  }
66  return container;
67  }
68 }
69 
70 IDPerfMonWenu::IDPerfMonWenu( const std::string & type, const std::string & name, const IInterface* parent )
71  :ManagedMonitorToolBase( type, name, parent ),
72  m_region_strings{"incl", "barrel", "eca", "ecc"},
73  m_triggerChainName("NoTriggerSelection")
74 {
75  declareProperty("tracksName",m_tracksName);
76  declareProperty("electronsName",m_electronsName="Electrons");
77  declareProperty("photonsName",m_photonsName="Photons");
78  declareProperty("VxPrimContainerName",m_VxPrimContainerName="PrimaryVertices");
79  declareProperty("emclustersName",m_emclustersName="LArClusterEM");
80  declareProperty("metName",m_metName="MET_Reference_AntiKt4LCTopo");
81  declareProperty("METFinalName",m_metRefFinalName="FinalClus");
82  declareProperty("eoverp_standard_min",m_eoverp_standard_min=0.5);
83  declareProperty("eoverp_standard_max",m_eoverp_standard_max=4.0);
84  declareProperty("eoverp_tight_min",m_eoverp_tight_min=0.7);
85  declareProperty("eoverp_tight_max",m_eoverp_tight_max=1.3);
86  declareProperty("CheckRate",m_checkrate=1000);
87  declareProperty("triggerChainName",m_triggerChainName);
88  declareProperty("rejectSecondCluster",m_rejectSecondCluster = true);
89  declareProperty("electronIDLevel",m_electronIDLevel = "Tight");
90 }
91 
92 IDPerfMonWenu::~IDPerfMonWenu() { }
93 
94 StatusCode IDPerfMonWenu::initialize(){
95  m_histosBooked = 0;
96  if (m_tracksName.empty() ){
97  ATH_MSG_WARNING( " no track collection given" );
98  }
99  StatusCode sc = ManagedMonitorToolBase::initialize();
100  if (sc.isFailure()){
101  ATH_MSG_WARNING( "Could not initialize ManagedMonitorToolBase" );
102  }
103  //---Electron Likelihood tool---
104  ATH_MSG_DEBUG("IDPerfMonWenu::Initialize() -- Setting up electron LH tool.");
105  m_LHTool2015=std::make_unique<AsgElectronLikelihoodTool> ("m_LHTool2015");
106  if((m_LHTool2015->setProperty("primaryVertexContainer",m_VxPrimContainerName)).isFailure()){
107  ATH_MSG_WARNING("Failure setting primary vertex container " << m_VxPrimContainerName << "in electron likelihood tool");
108  }
109  //Set up electron LH level
110  m_doIDCuts = true;
111  std::string confDir = "ElectronPhotonSelectorTools/offline/mc15_20150712/";
112  if(m_electronIDLevel .empty()){
113  ATH_MSG_WARNING("electronIDLevel is set to empty! No electron ID cuts will be applied.");
114  m_doIDCuts = false;
115  } else {
116  if((m_electronIDLevel != "Loose") && (m_electronIDLevel != "Medium") && (m_electronIDLevel != "Tight")){
117  ATH_MSG_WARNING("Unknown electronIDLevel!! (Accepted values: Loose, Medium, Tight)");
118  m_doIDCuts = false;
119  } else {
120  std::string configFile = confDir+"ElectronLikelihood"+m_electronIDLevel+"OfflineConfig2015.conf";
121  ATH_MSG_INFO("Likelihood configuration file: " << configFile);
122  if((m_LHTool2015->setProperty("ConfigFile",configFile)).isFailure()){
123  ATH_MSG_WARNING("Failure loading ConfigFile in electron likelihood tool.");
124  }
125  }
126  }
127  StatusCode lh = m_LHTool2015->initialize();
128  if(lh.isFailure()){
129  ATH_MSG_WARNING("Electron likelihood tool initialize() failed! Turning off electron LH cuts!");
130  m_doIDCuts = false;
131  }
132  return StatusCode::SUCCESS;
133 }
134 
135 StatusCode IDPerfMonWenu::bookHistograms()
136 {
137  MonGroup al_Wenu_mon ( this, "IDPerfMon/Wenu/" + m_triggerChainName, run);
138  if( newRunFlag() ) {
139  //if user environment specified we don't want to book new histograms at every run boundary
140  //we instead want one histogram per job
141  if(m_histosBooked!=0 && AthenaMonManager::environment()==AthenaMonManager::user) return StatusCode::SUCCESS;
142 
143  // ***********************
144  // Book event histograms
145  // ***********************
146 
147  m_Nevents = new TH1F("Nevents", "Number of events processed", 1, -.5, 0.5);
148  RegisterHisto(al_Wenu_mon,m_Nevents);
149  m_Wenu_met_sel = new TH1F("Wenu_met_sel","met", 50, 0., 100.);
150  RegisterHisto(al_Wenu_mon,m_Wenu_met_sel);
151  m_Wenu_transmass_sel = new TH1F("Wenu_transmass_sel","Transverse mass of the leading em cluster and the met", 90, 0., 180.);
152  RegisterHisto(al_Wenu_mon,m_Wenu_transmass_sel);
153  m_Wenu_trk_transmass_sel = new TH1F("Wenu_trk_transmass_sel","Transverse mass of the track and the met", 90, 0., 180.);
154  RegisterHisto(al_Wenu_mon,m_Wenu_trk_transmass_sel);
155  m_Wenu_trk_transmass_sel_scaled = new TH1F("Wenu_trk_transmass_sel_scaled","Transverse mass of the track and the met scaled to per event", 90, 0., 180.);
156  RegisterHisto(al_Wenu_mon,m_Wenu_trk_transmass_sel_scaled);
157  m_Wenu_clus_pt = new TH1F("Wenu_cluster_pt","Transverse momentum of the leading em cluster",50,0.,100.);
158  RegisterHisto(al_Wenu_mon,m_Wenu_clus_pt);
159 
160  // ***********************
161  // Book cluster histograms
162  // ***********************
163 
164  // first take care to clear all histogram vectors
165  m_Wenu_Eop.clear();
166  m_Wenu_Eopdiff.clear();
167  m_Wenu_Eop_plus.clear();
168  m_Wenu_Eop_minus.clear();
169  m_Wenu_eta.clear();
170  m_Wenu_phi.clear();
171  m_Wenu_deta.clear();
172  m_Wenu_deta_vs_eta.clear();
173  m_Wenu_deta_vs_phi.clear();
174  m_Wenu_absdeta_vs_eta.clear();
175  m_Wenu_absdeta_vs_phi.clear();
176  m_Wenu_dphi.clear();
177  m_Wenu_dphi_vs_eta.clear();
178  m_Wenu_dphi_vs_phi.clear();
179  m_Wenu_absdphi_vs_eta.clear();
180  m_Wenu_absdphi_vs_phi.clear();
181  m_Wenu_trackmatched_eta.clear();
182  m_Wenu_trackmatched_phi.clear();
183  m_Wenu_trackmatched_Eopmatched_eta.clear();
184  m_Wenu_trackmatched_Eopmatched_phi.clear();
185  m_Wenu_trackmatched_tightEopmatched_eta.clear();
186  m_Wenu_trackmatched_tightEopmatched_phi.clear();
187  m_Wenu_trackmatch_eff_vs_eta.clear();
188  m_Wenu_trackmatch_eff_vs_phi.clear();
189  m_Wenu_Eopmatch_eff_vs_eta.clear();
190  m_Wenu_Eopmatch_eff_vs_phi.clear();
191  m_Wenu_tightEopmatch_eff_vs_eta.clear();
192  m_Wenu_tightEopmatch_eff_vs_phi.clear();
193  m_Wenu_meanEop_vs_p.clear();
194  m_Wenu_meanEop_vs_invp.clear();
195  m_Wenu_meanEop_vs_E.clear();
196  m_Wenu_meanEop_vs_chargedp.clear();
197  m_Wenu_meanEop_vs_chargedE.clear();
198  m_Wenu_meanEop_vs_phi.clear();
199  m_Wenu_meanEop_vs_eta.clear();
200  m_Wenu_meanEop_vs_p_plus.clear();
201  m_Wenu_meanEop_vs_invp_plus.clear();
202  m_Wenu_meanEop_vs_E_plus.clear();
203  m_Wenu_meanEop_vs_phi_plus.clear();
204  m_Wenu_meanEop_vs_eta_plus.clear();
205  m_Wenu_meanEop_vs_p_minus.clear();
206  m_Wenu_meanEop_vs_invp_minus.clear();
207  m_Wenu_meanEop_vs_E_minus.clear();
208  m_Wenu_meanEop_vs_phi_minus.clear();
209  m_Wenu_meanEop_vs_eta_minus.clear();
210  m_Wenu_Eop_lt1_gt1.clear();
211  m_Wenu_Eopdiff_vs_p.clear();
212  m_Wenu_Eopdiff_vs_invp.clear();
213  m_Wenu_Eopdiff_vs_E.clear();
214  m_Wenu_Eopdiff_vs_phi.clear();
215  m_Wenu_Eopdiff_vs_eta.clear();
216  m_Wenu_Eop_lt1_vs_eta.clear();
217  m_Wenu_Eop_lt1_vs_phi.clear();
218  m_Wenu_Eop_gt1_vs_eta.clear();
219  m_Wenu_Eop_gt1_vs_phi.clear();
220  m_Wenu_frac_Eop_lt1_vs_eta.clear();
221  m_Wenu_frac_Eop_lt1_vs_phi.clear();
222  m_Wenu_Eop_05_25.clear();
223  m_Wenu_Eop_15_25.clear();
224  m_Wenu_frac_Eop_05_25_15_25.clear();
225 
226  for (int region=0; region!=Nregions; ++region) {
227  std::string title;
228  std::string name;
229 
230  name = "Wenu_Eop_" + m_region_strings[region];
231  title = "E/p for Wenu EM-clusters in " + m_region_strings[region];
232  m_Wenu_Eop.push_back(new TH1F(name.c_str(),title.c_str(), 60, 0., 10.));
233 
234  RegisterHisto(al_Wenu_mon,m_Wenu_Eop[region]);
235  name = "Wenu_Eopdiff_" + m_region_strings[region];
236  title = "E/p difference (pos-neg) for Wenu EM-clusters in " + m_region_strings[region];
237  m_Wenu_Eopdiff.push_back(new TH1F(name.c_str(),title.c_str(), 10, 0., 2.));
238 
239  RegisterHisto(al_Wenu_mon,m_Wenu_Eopdiff[region],true);
240  name = "Wenu_Eop_plus_" + m_region_strings[region];
241  title = "E/p for pos. charged Wenu EM-clusters in " + m_region_strings[region];
242  m_Wenu_Eop_plus.push_back(new TH1F(name.c_str(),title.c_str(), 10, 0., 2.));
243  RegisterHisto(al_Wenu_mon,m_Wenu_Eop_plus[region],true);
244 
245  name = "Wenu_Eop_minus_" + m_region_strings[region];
246  title = "E/p for neg. charged Wenu EM-clusters in " + m_region_strings[region];
247  m_Wenu_Eop_minus.push_back(new TH1F(name.c_str(),title.c_str(), 10, 0., 2.));
248  RegisterHisto(al_Wenu_mon,m_Wenu_Eop_minus[region],true);
249 
250  if (region != incl) continue;
251 
252  m_Wenu_eta.push_back(new TH1F("Wenu_eta","Eta of Wenu EM-clusters", 15, -3., 3.));
253  RegisterHisto(al_Wenu_mon,m_Wenu_eta[region]);
254  m_Wenu_phi.push_back(new TH1F("Wenu_phi","Phi of Wenu EM-clusters", 15, -3.15, 3.15));
255  RegisterHisto(al_Wenu_mon,m_Wenu_phi[region]);
256 
257  m_Wenu_deta.push_back(new TH1F("Wenu_deta","deltaEta(EM-cluster,track) in Wenu events", 50, -0.5, 0.5));
258  RegisterHisto(al_Wenu_mon,m_Wenu_deta[region]);
259  m_Wenu_deta_vs_eta.push_back(new TProfile("Wenu_deta_vs_eta","deltaEta(EM-cluster,track) vs. eta in Wenu events", 15, -3., 3.));
260  RegisterHisto(al_Wenu_mon,m_Wenu_deta_vs_eta[region]);
261  m_Wenu_deta_vs_phi.push_back(new TProfile("Wenu_deta_vs_phi","deltaEta(EM-cluster,track) vs. phi in Wenu events", 15, -3.15, 3.15));
262  RegisterHisto(al_Wenu_mon,m_Wenu_deta_vs_phi[region]);
263  m_Wenu_absdeta_vs_eta.push_back(new TProfile("Wenu_absdeta_vs_eta","Abs(deltaEta(EM-cluster,track)) vs. eta in Wenu events", 15, -3., 3.));
264  RegisterHisto(al_Wenu_mon,m_Wenu_absdeta_vs_eta[region]);
265  m_Wenu_absdeta_vs_phi.push_back(new TProfile("Wenu_absdeta_vs_phi","Abs(deltaEta(EM-cluster,track)) vs. phi in Wenu events", 15, -3.15, 3.15));
266  RegisterHisto(al_Wenu_mon,m_Wenu_absdeta_vs_phi[region]);
267  m_Wenu_dphi.push_back(new TH1F("Wenu_dphi","deltaPhi(EM-cluster,track) in Wenu events", 50, -0.5, 0.5));
268  RegisterHisto(al_Wenu_mon,m_Wenu_dphi[region]);
269  m_Wenu_dphi_vs_eta.push_back(new TProfile("Wenu_dphi_vs_eta","deltaPhi(EM-cluster,track) vs. eta in Wenu events", 15, -3., 3.));
270  RegisterHisto(al_Wenu_mon,m_Wenu_dphi_vs_eta[region]);
271  m_Wenu_dphi_vs_phi.push_back(new TProfile("Wenu_dphi_vs_phi","deltaPhi(EM-cluster,track) vs. phi in Wenu events", 15, -3.15, 3.15));
272  RegisterHisto(al_Wenu_mon,m_Wenu_dphi_vs_phi[region]);
273  m_Wenu_absdphi_vs_eta.push_back(new TProfile("Wenu_absdphi_vs_eta","Abs(deltaPhi(EM-cluster,track)) vs. eta in Wenu events", 15, -3., 3.));
274  RegisterHisto(al_Wenu_mon,m_Wenu_absdphi_vs_eta[region]);
275  m_Wenu_absdphi_vs_phi.push_back(new TProfile("Wenu_absdphi_vs_phi","Abs(deltaPhi(EM-cluster,track)) vs. phi in Wenu events", 15, -3.15, 3.15));
276  RegisterHisto(al_Wenu_mon,m_Wenu_absdphi_vs_phi[region]);
277 
278  m_Wenu_trackmatched_eta.push_back(new TH1F("Wenu_trackmatched_eta","Eta of track-matched Wenu EM-clusters", 15, -3., 3.));
279  RegisterHisto(al_Wenu_mon,m_Wenu_trackmatched_eta[region]);
280  m_Wenu_trackmatched_phi.push_back(new TH1F("Wenu_trackmatched_phi","Phi of track-matched Wenu EM-clusters", 15, -3.15, 3.15));
281  RegisterHisto(al_Wenu_mon,m_Wenu_trackmatched_phi[region]);
282  m_Wenu_trackmatched_Eopmatched_eta.push_back(new TH1F("Wenu_trackmatched_Eopmatched_eta","Eta of track-matched and E/p-matched Wenu EM-clusters", 15, -3., 3.));
283  RegisterHisto(al_Wenu_mon,m_Wenu_trackmatched_Eopmatched_eta[region]);
284  m_Wenu_trackmatched_Eopmatched_phi.push_back(new TH1F("Wenu_trackmatched_Eopmatched_phi","Phi of track-matched and E/p-matched Wenu EM-clusters", 15, -3.15, 3.15));
285  RegisterHisto(al_Wenu_mon,m_Wenu_trackmatched_Eopmatched_phi[region]);
286  m_Wenu_trackmatched_tightEopmatched_eta.push_back(new TH1F("Wenu_trackmatched_tightEopmatched_eta","Eta of track-matched and tight E/p-matched Wenu EM-clusters", 15, -3., 3.));
287  RegisterHisto(al_Wenu_mon,m_Wenu_trackmatched_tightEopmatched_eta[region]);
288  m_Wenu_trackmatched_tightEopmatched_phi.push_back(new TH1F("Wenu_trackmatched_tightEopmatched_phi","Phi of track-matched and tight E/p-matched Wenu EM-clusters", 15, -3.15, 3.15));
289  RegisterHisto(al_Wenu_mon,m_Wenu_trackmatched_tightEopmatched_phi[region]);
290 
291  m_Wenu_trackmatch_eff_vs_eta.push_back(new TH1F("Wenu_trackmatch_eff_vs_eta","Track-match efficiency for Wenu EM-clusters vs. eta", 15, -3., 3.));
292  RegisterHisto(al_Wenu_mon,m_Wenu_trackmatch_eff_vs_eta[region],1);
293  m_Wenu_trackmatch_eff_vs_phi.push_back(new TH1F("Wenu_trackmatch_eff_vs_phi","Track-match efficiency for Wenu EM-clusters vs. phi", 15, -3.15, 3.15));
294  RegisterHisto(al_Wenu_mon,m_Wenu_trackmatch_eff_vs_phi[region],1);
295  m_Wenu_Eopmatch_eff_vs_eta.push_back(new TH1F("Wenu_Eopmatch_eff_vs_eta","E/p-match efficiency for Wenu EM-clusters vs. eta", 15, -3., 3.));
296  RegisterHisto(al_Wenu_mon,m_Wenu_Eopmatch_eff_vs_eta[region],1);
297  m_Wenu_Eopmatch_eff_vs_phi.push_back(new TH1F("Wenu_Eopmatch_eff_vs_phi","E/p-match efficiency for Wenu EM-clusters vs. phi", 15, -3.15, 3.15));
298  RegisterHisto(al_Wenu_mon,m_Wenu_Eopmatch_eff_vs_phi[region],1);
299  m_Wenu_tightEopmatch_eff_vs_eta.push_back(new TH1F("Wenu_tightEopmatch_eff_vs_eta","Tight E/p-match efficiency for Wenu EM-clusters vs. eta", 15, -3., 3.));
300  RegisterHisto(al_Wenu_mon,m_Wenu_tightEopmatch_eff_vs_eta[region],1);
301  m_Wenu_tightEopmatch_eff_vs_phi.push_back(new TH1F("Wenu_tightEopmatch_eff_vs_phi","Tight E/p-match efficiency for Wenu EM-clusters vs. phi", 15, -3.15, 3.15));
302  RegisterHisto(al_Wenu_mon,m_Wenu_tightEopmatch_eff_vs_phi[region],1);
303 
304  m_Wenu_meanEop_vs_p.push_back(new TProfile("Wenu_meanEop_vs_p", "Mean E/p vs p for Wenu EM-clusters", 15, 0., 300.));
305  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_p[region]);
306  m_Wenu_meanEop_vs_invp.push_back(new TProfile("Wenu_meanEop_vs_invp", "Mean E/p vs 1/p for Wenu EM-clusters", 15, 0., 0.05));
307  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_invp[region]);
308  m_Wenu_meanEop_vs_E.push_back(new TProfile("Wenu_meanEop_vs_E", "Mean E/p vs E for Wenu EM-clusters", 15, 0., 300.));
309  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_E[region]);
310  m_Wenu_meanEop_vs_chargedp.push_back(new TProfile("Wenu_meanEop_vs_chargedp", "Mean E/p vs charge*p for Wenu EM-clusters", 30, -300., 300.));
311  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_chargedp[region]);
312  m_Wenu_meanEop_vs_chargedE.push_back(new TProfile("Wenu_meanEop_vs_chargedE", "Mean E/p vs charge*E for Wenu EM-clusters", 30, -300., 300.));
313  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_chargedE[region]);
314  m_Wenu_meanEop_vs_phi.push_back(new TProfile("Wenu_meanEop_vs_phi", "Mean E/p vs phi for Wenu EM-clusters", 15, -3.15, 3.15));
315  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_phi[region]);
316  m_Wenu_meanEop_vs_eta.push_back(new TProfile("Wenu_meanEop_vs_eta", "Mean E/p vs eta for Wenu EM-clusters", 15, -3., 3.));
317  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_eta[region]);
318 
319  m_Wenu_meanEop_vs_p_plus.push_back(new TProfile("Wenu_meanEop_vs_p_plus", "Mean E/p vs p for pos. charged Wenu EM-clusters", 15, 0., 300.));
320  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_p_plus[region]);
321  m_Wenu_meanEop_vs_invp_plus.push_back(new TProfile("Wenu_meanEop_vs_invp_plus", "Mean E/p vs 1/p for pos. charged Wenu EM-clusters", 15, 0., 0.05));
322  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_invp_plus[region]);
323  m_Wenu_meanEop_vs_E_plus.push_back(new TProfile("Wenu_meanEop_vs_E_plus", "Mean E/p vs E for pos. charged Wenu EM-clusters", 15, 0., 300.));
324  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_E_plus[region]);
325  m_Wenu_meanEop_vs_phi_plus.push_back(new TProfile("Wenu_meanEop_vs_phi_plus", "Mean E/p vs phi for pos. charged Wenu EM-clusters", 15, -3.15, 3.15));
326  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_phi_plus[region]);
327  m_Wenu_meanEop_vs_eta_plus.push_back(new TProfile("Wenu_meanEop_vs_eta_plus", "Mean E/p vs eta for pos. charged Wenu EM-clusters", 15, -3., 3.));
328  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_eta_plus[region]);
329 
330  m_Wenu_meanEop_vs_p_minus.push_back(new TProfile("Wenu_meanEop_vs_p_minus", "Mean E/p vs p for neg. charged Wenu EM-clusters", 15, 0., 300.));
331  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_p_minus[region]);
332  m_Wenu_meanEop_vs_invp_minus.push_back(new TProfile("Wenu_meanEop_vs_invp_minus", "Mean E/p vs 1/p for neg. charged Wenu EM-clusters", 15, 0., 0.05));
333  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_invp_minus[region]);
334  m_Wenu_meanEop_vs_E_minus.push_back(new TProfile("Wenu_meanEop_vs_E_minus", "Mean E/p vs E for neg. charged Wenu EM-clusters", 15, 0., 300.));
335  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_E_minus[region]);
336  m_Wenu_meanEop_vs_phi_minus.push_back(new TProfile("Wenu_meanEop_vs_phi_minus", "Mean E/p vs phi for neg. charged Wenu EM-clusters", 15, -3.15, 3.15));
337  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_phi_minus[region]);
338  m_Wenu_meanEop_vs_eta_minus.push_back(new TProfile("Wenu_meanEop_vs_eta_minus", "Mean E/p vs eta for neg. charged Wenu EM-clusters", 15, -3., 3.));
339  RegisterHisto(al_Wenu_mon,m_Wenu_meanEop_vs_eta_minus[region]);
340 
341  m_Wenu_Eop_lt1_gt1.push_back(new TH1F("Wenu_Eop_lt1_gt1", "E/p below/above 1 for Wenu EM-clusters", 2, 0.5, 1.5));
342  RegisterHisto(al_Wenu_mon,m_Wenu_Eop_lt1_gt1[region]);
343 
344  m_Wenu_Eopdiff_vs_p.push_back(new TProfile("Wenu_Eopdiff_vs_p", "E/p difference (pos-neg) vs p for Wenu EM-clusters", 15, 0., 300.));
345  RegisterHisto(al_Wenu_mon,m_Wenu_Eopdiff_vs_p[region]);
346  m_Wenu_Eopdiff_vs_invp.push_back(new TProfile("Wenu_Eopdiff_vs_invp", "E/p difference (pos-neg) vs 1/p for Wenu EM-clusters", 15, 0., 0.05));
347  RegisterHisto(al_Wenu_mon,m_Wenu_Eopdiff_vs_invp[region]);
348  m_Wenu_Eopdiff_vs_E.push_back(new TProfile("Wenu_Eopdiff_vs_E", "E/p difference (pos-neg) vs E for Wenu EM-clusters", 15, 0., 300.));
349  RegisterHisto(al_Wenu_mon,m_Wenu_Eopdiff_vs_E[region]);
350  m_Wenu_Eopdiff_vs_phi.push_back(new TProfile("Wenu_Eopdiff_vs_phi", "E/p difference (pos-neg) vs phi for Wenu EM-clusters", 15, -3.15, 3.15));
351  RegisterHisto(al_Wenu_mon,m_Wenu_Eopdiff_vs_phi[region]);
352  m_Wenu_Eopdiff_vs_eta.push_back(new TProfile("Wenu_Eopdiff_vs_eta", "E/p difference (pos-neg) vs eta for Wenu EM-clusters", 15, -3., 3.));
353  RegisterHisto(al_Wenu_mon,m_Wenu_Eopdiff_vs_eta[region]);
354 
355  m_Wenu_Eop_lt1_vs_eta.push_back(new TH1F("Wenu_Eop_lt1_vs_eta","Eta of Wenu EM-clusters with E/p < 1 (not incl. small E/p)", 15, -3., 3.));
356  RegisterHisto(al_Wenu_mon,m_Wenu_Eop_lt1_vs_eta[region]);
357  m_Wenu_Eop_lt1_vs_phi.push_back(new TH1F("Wenu_Eop_lt1_vs_phi","Phi of Wenu EM-clusters with E/p < 1 (not incl. small E/p)", 15, -3.15, 3.15));
358  RegisterHisto(al_Wenu_mon,m_Wenu_Eop_lt1_vs_phi[region]);
359  m_Wenu_Eop_gt1_vs_eta.push_back(new TH1F("Wenu_Eop_gt1_vs_eta","Eta of Wenu EM-clusters with E/p < 1 (not incl. small E/p)", 15, -3., 3.));
360  RegisterHisto(al_Wenu_mon,m_Wenu_Eop_gt1_vs_eta[region]);
361  m_Wenu_Eop_gt1_vs_phi.push_back(new TH1F("Wenu_Eop_gt1_vs_phi","Phi of Wenu EM-clusters with E/p < 1 (not incl. small E/p)", 15, -3.15, 3.15));
362  RegisterHisto(al_Wenu_mon,m_Wenu_Eop_gt1_vs_phi[region]);
363  m_Wenu_frac_Eop_lt1_vs_eta.push_back(new TH1F("Wenu_frac_Eop_lt1_vs_eta","Fraction of Wenu EM-clusters with E/p < 1 (not incl. small E/p) vs Eta", 15, -3., 3.));
364  RegisterHisto(al_Wenu_mon,m_Wenu_frac_Eop_lt1_vs_eta[region],1);
365  m_Wenu_frac_Eop_lt1_vs_phi.push_back(new TH1F("Wenu_frac_Eop_lt1_vs_phi","Fraction of Wenu EM-clusters with E/p < 1 (not incl. small E/p) vs Phi", 15, -3.15, 3.15));
366  RegisterHisto(al_Wenu_mon,m_Wenu_frac_Eop_lt1_vs_phi[region],1);
367 
368  m_Wenu_Eop_05_25.push_back(new TH1F("Wenu_Eop_05_25","Number of Wenu events with 0.5 < E/p 2.5", 1, 0., 1.));
369  RegisterHisto(al_Wenu_mon,m_Wenu_Eop_05_25[region]);
370  m_Wenu_Eop_15_25.push_back(new TH1F("Wenu_Eop_15_25","Number of Wenu events with 1.5 < E/p 2.5", 1, 0., 1.));
371  RegisterHisto(al_Wenu_mon,m_Wenu_Eop_15_25[region]);
372  m_Wenu_frac_Eop_05_25_15_25.push_back(new TH1F("Wenu_frac_Eop_05_25_15_25","Fraction of Wenu EM-clusters with 1.5 < E/p < 2.5 and 0.5 < E/p < 2.5", 1, 0., 1.));
373  RegisterHisto(al_Wenu_mon,m_Wenu_frac_Eop_05_25_15_25[region],1);
374  }
375 
376  m_histosBooked++;
377  }
378  return StatusCode::SUCCESS;
379 }
380 
381 void IDPerfMonWenu::RegisterHisto(MonGroup& mon, TH1* histo, bool doSumw2) {
382  if (doSumw2) histo->Sumw2();
383  StatusCode sc = mon.regHist(histo);
384  if (sc.isFailure() ) {
385  ATH_MSG_DEBUG( "Cannot book TH1 Histogram:" );
386  }
387 }
388 
389 void IDPerfMonWenu::RegisterHisto(MonGroup& mon, TProfile* histo) {
390  if (mon.regHist(histo).isFailure() ) {
391  ATH_MSG_DEBUG( "Cannot book TProfile Histogram:" );
392  }
393 }
394 
395 void IDPerfMonWenu::RegisterHisto(MonGroup& mon, TH2* histo, bool doSumw2) {
396  if (doSumw2) histo->Sumw2();
397  if (mon.regHist(histo).isFailure() ) {
398  ATH_MSG_WARNING( "Cannot book TH2 Histogram:" );
399  }
400 }
401 
402 StatusCode IDPerfMonWenu::fillHistograms()
403 {
404  int nevents = (int) m_Nevents->GetEntries();
405  const bool firstEvent{nevents == 1};
406  // get electron container from storegate
407  auto formErrorMessage = [] (const std::string & contName)->std::string {
408  return std::string(std::string("No Collection with name ") + contName + std::string(" found in StoreGate"));
409  };
410  const xAOD::ElectronContainer* electrons = PerfMonServices::getContainer<xAOD::ElectronContainer>( PerfMonServices::ELECTRON_COLLECTION );
411 
412  if (not electrons){
413  const std::string & errMsg=formErrorMessage(m_electronsName);
414  if (firstEvent) ATH_MSG_WARNING( errMsg );
415  else ATH_MSG_DEBUG(errMsg);
416  return StatusCode::RECOVERABLE;
417  }
418  // get photon container from storegate
419  const xAOD::PhotonContainer* photons = getCollectionWithCheck<xAOD::PhotonContainer>(evtStore(),m_photonsName);
420  if (not photons){
421  const std::string & errMsg = formErrorMessage(m_photonsName);
422  if (firstEvent) ATH_MSG_WARNING( errMsg );
423  else ATH_MSG_DEBUG(errMsg);
424  return StatusCode::RECOVERABLE;
425  }
426  // get emcluster container from storegate
427  const xAOD::CaloClusterContainer* emclusters = getCollectionWithCheck<xAOD::CaloClusterContainer>(evtStore(),m_emclustersName);
428  if (not emclusters){
429  const std::string & errMsg = formErrorMessage(m_emclustersName);
430  if (firstEvent) ATH_MSG_WARNING( errMsg );
431  else ATH_MSG_DEBUG(errMsg);
432  return StatusCode::RECOVERABLE;
433  }
434  // get track container from storegate
435  const xAOD::TrackParticleContainer* tracks = getCollectionWithCheck<xAOD::TrackParticleContainer>(evtStore(),m_tracksName);
436  if (not tracks){
437  const std::string & errMsg = formErrorMessage(m_tracksName);
438  if (firstEvent) ATH_MSG_WARNING( errMsg );
439  else ATH_MSG_DEBUG(errMsg);
440  return StatusCode::RECOVERABLE;
441  }
442  // get met container from storegate
443  const xAOD::MissingETContainer* final_met = getCollectionWithCheck<xAOD::MissingETContainer>(evtStore(),m_metName);
444  if (not final_met){
445  const std::string & errMsg = formErrorMessage(m_metName);
446  if (firstEvent) ATH_MSG_WARNING( errMsg );
447  else ATH_MSG_DEBUG(errMsg);
448  return StatusCode::RECOVERABLE;
449  }
450  m_Nevents->Fill(0.);
451  // ******************
452  // Get the missing ET
453  // ******************
454  const xAOD::MissingET *MET;
455  MET = (*final_met)[m_metRefFinalName];
456  double met = MET->met();
457  msg(MSG::DEBUG) << "MET = " << met << endmsg;
458  // *******************
459  // Look at EM clusters
460  // *******************
461  const xAOD::CaloCluster* LeadingEMcluster = getLeadingEMcluster(photons, electrons);
462  const xAOD::CaloCluster* SecondLeadingEMcluster = getLeadingEMcluster(photons, electrons, LeadingEMcluster);
463  if (LeadingEMcluster) {
464  int leading_eta_region = etaRegion(LeadingEMcluster->eta());
465  double leading_dPhi = electronTrackMatchEta(tracks,LeadingEMcluster);
466  double leading_dEta = electronTrackMatchPhi(tracks,LeadingEMcluster);
467  const xAOD::TrackParticle* track_leading_emcluster = electronTrackMatch(tracks,LeadingEMcluster);
468  int selected = isWenu(LeadingEMcluster, SecondLeadingEMcluster, met);
469  if (selected == 0) {
470  // *********************
471  // Fill event histograms
472  // *********************
473  m_Wenu_met_sel->Fill(met/Gaudi::Units::GeV);
474  m_Wenu_clus_pt->Fill(LeadingEMcluster->pt()/Gaudi::Units::GeV);
475  double cluster_met_transmass = TransMass(LeadingEMcluster,MET);
476  if (cluster_met_transmass > 0.) m_Wenu_transmass_sel->Fill(cluster_met_transmass);
477  double track_met_transmass = 0.;
478  if (track_leading_emcluster ) {
479  track_met_transmass = TransMass(track_leading_emcluster,MET);
480  if (track_met_transmass > 0.) m_Wenu_trk_transmass_sel->Fill(track_met_transmass);
481  }
482  // ***********************
483  // Fill cluster histograms
484  // ***********************
485  FillHistosPerCluster(LeadingEMcluster, track_leading_emcluster, leading_eta_region, leading_dEta, leading_dPhi);
486  FillHistosPerCluster(LeadingEMcluster, track_leading_emcluster, incl, leading_dEta, leading_dPhi);
487  }
488  }
489  return StatusCode::SUCCESS;
490 }
491 
492 void IDPerfMonWenu::makeEffHisto(TH1F* h_num, TH1F* h_denom, TH1F* h_eff) {
493  h_eff->Divide(h_num,h_denom,1.,1.,"B");
494 }
495 
496 StatusCode IDPerfMonWenu::procHistograms()
497 {
498  if( endOfRunFlag() ) {
499  // PostProcess Wenu histograms
500  for (int region=0; region!=1; ++region) {
501  makeEffHisto(m_Wenu_trackmatched_eta[region],m_Wenu_eta[region],m_Wenu_trackmatch_eff_vs_eta[region]);
502  makeEffHisto(m_Wenu_trackmatched_phi[region],m_Wenu_phi[region],m_Wenu_trackmatch_eff_vs_phi[region]);
503  makeEffHisto(m_Wenu_trackmatched_Eopmatched_eta[region],m_Wenu_trackmatched_eta[region],m_Wenu_Eopmatch_eff_vs_eta[region]);
504  makeEffHisto(m_Wenu_trackmatched_Eopmatched_phi[region],m_Wenu_trackmatched_phi[region],m_Wenu_Eopmatch_eff_vs_phi[region]);
505  makeEffHisto(m_Wenu_trackmatched_tightEopmatched_eta[region],m_Wenu_trackmatched_eta[region],m_Wenu_tightEopmatch_eff_vs_eta[region]);
506  makeEffHisto(m_Wenu_trackmatched_tightEopmatched_phi[region],m_Wenu_trackmatched_phi[region],m_Wenu_tightEopmatch_eff_vs_phi[region]);
507  // commented out for some reason?
508  m_Wenu_Eopdiff[region]->Add(m_Wenu_Eop_plus[region],m_Wenu_Eop_minus[region],1.,-1);
509  m_Wenu_Eopdiff_vs_p[region]->Add(m_Wenu_meanEop_vs_p_plus[region],m_Wenu_meanEop_vs_p_minus[region],1.,-1);
510  m_Wenu_Eopdiff_vs_invp[region]->Add(m_Wenu_meanEop_vs_invp_plus[region],m_Wenu_meanEop_vs_invp_minus[region],1.,-1);
511  m_Wenu_Eopdiff_vs_E[region]->Add(m_Wenu_meanEop_vs_E_plus[region],m_Wenu_meanEop_vs_E_minus[region],1.,-1);
512  m_Wenu_Eopdiff_vs_phi[region]->Add(m_Wenu_meanEop_vs_phi_plus[region],m_Wenu_meanEop_vs_phi_minus[region],1.,-1);
513  m_Wenu_Eopdiff_vs_eta[region]->Add(m_Wenu_meanEop_vs_eta_plus[region],m_Wenu_meanEop_vs_eta_minus[region],1.,-1);
514  //
515  makeEffHisto(m_Wenu_Eop_lt1_vs_eta[region],m_Wenu_eta[region],m_Wenu_frac_Eop_lt1_vs_eta[region]);
516  makeEffHisto(m_Wenu_Eop_lt1_vs_phi[region],m_Wenu_phi[region],m_Wenu_frac_Eop_lt1_vs_phi[region]);
517  makeEffHisto(m_Wenu_Eop_15_25[region],m_Wenu_Eop_05_25[region],m_Wenu_frac_Eop_05_25_15_25[region]);
518  }
519  }
520  return StatusCode::SUCCESS;
521 }
522 
523 
524 const xAOD::CaloCluster* IDPerfMonWenu::getLeadingEMcluster(const xAOD::CaloClusterContainer* clusters, const xAOD::CaloCluster* omitCluster) const {
525  const xAOD::CaloCluster* leading_emcluster{nullptr};
526  float max_pt = 0.;
527  for (const auto cl: *clusters) {
528  if (cl == omitCluster) continue;
529  double deltaR = std::sqrt(std::pow(std::abs(cl->phi() - omitCluster->phi()),2) + std::pow(std::abs(cl->eta() - omitCluster->eta()),2));
530  if(deltaR < 0.005) continue;
531  if (cl->pt()/Gaudi::Units::GeV < 10.) continue;
532  if (cl->pt() > max_pt) {
533  leading_emcluster = cl;
534  max_pt = cl->pt();
535  }
536  }
537  return leading_emcluster;
538 }
539 
540 const xAOD::CaloCluster* IDPerfMonWenu::getLeadingEMcluster(const xAOD::PhotonContainer* /*photons*/, const xAOD::ElectronContainer* electrons, const xAOD::CaloCluster* omitCluster) const {
541  const xAOD::CaloCluster* leading_emcluster = nullptr;
542  bool LHSel;
543  float max_pt = 0.;
544  for (const auto em: *electrons) {
545  // check ID
546  if(m_doIDCuts){
547  LHSel = false;
548  LHSel = (bool) m_LHTool2015->accept(em);
549  if(!LHSel) continue;
550  ATH_MSG_DEBUG("Electron passes " << m_electronIDLevel << " likelihood selection");
551  }
552  const xAOD::CaloCluster* cl = em->caloCluster();
553  if (cl == omitCluster) continue;
554  if (cl->pt()/Gaudi::Units::GeV < 10.) continue;
555  if (cl->pt() > max_pt) {
556  leading_emcluster = cl;
557  max_pt = cl->pt();
558  }
559  }
560  return leading_emcluster;
561 
562 }
563 
564 const xAOD::TrackParticle* IDPerfMonWenu::electronTrackMatch(const xAOD::TrackParticleContainer* tracks, const xAOD::CaloCluster* cluster, double dEta, double dPhi) const {
565  const xAOD::TrackParticle* matched_track = nullptr;
566  double min_dR = 1.0e+20;
567  for (const auto track: *tracks) {
568  double deta = cluster->eta()-track->eta();
569  double dphi = cluster->phi()-track->phi();
570  double dr = std::sqrt(deta*deta + dphi*dphi);
571  if (dr < min_dR && std::abs(deta) < dEta && std::abs(dphi) < dPhi) {
572  min_dR = dr;
573  matched_track = track;
574  }
575  }
576  return matched_track;
577 }
578 
579 double IDPerfMonWenu::electronTrackMatchEta(const xAOD::TrackParticleContainer* tracks, const xAOD::CaloCluster* cluster, double dEta) const {
580  const xAOD::TrackParticle* matched_track = nullptr;
581  double min_dEta = 1.0e+20;
582  for (const auto track: *tracks) {
583  double deta = std::abs(cluster->eta()-track->eta());
584  if (deta < min_dEta && deta < dEta) {
585  min_dEta = deta;
586  matched_track = track;
587  }
588  }
589  double dPhi = 1.0e+20;
590  if (matched_track != nullptr) dPhi = signedDeltaPhi(cluster->phi(),matched_track->phi());
591  return dPhi;
592 }
593 
594 double IDPerfMonWenu::electronTrackMatchPhi(const xAOD::TrackParticleContainer* tracks, const xAOD::CaloCluster* cluster, double dPhi) const {
595  const xAOD::TrackParticle* matched_track = nullptr;
596  double min_dPhi = 1.0e+20;
597  for (const auto track : *tracks) {
598  double dphi = std::abs(signedDeltaPhi(cluster->phi(),track->phi()));
599  if (dphi < min_dPhi && dphi < dPhi) {
600  min_dPhi = dphi;
601  matched_track = track;
602  }
603  }
604  double dEta = 1.0e+20;
605  if (matched_track != nullptr) dEta = cluster->eta()-matched_track->eta();
606  return dEta;
607 
608 }
609 
610 int IDPerfMonWenu::isWenu(const xAOD::CaloCluster* em, const xAOD::CaloCluster* em2, double met) const {
611  int selected = 2;
612  if(em->pt()/Gaudi::Units::GeV > 25.) --selected;
613  if(met/Gaudi::Units::GeV > 20.) --selected; // was at 0 for some reason?
614  if(!m_rejectSecondCluster) return selected;
615  // else check 2nd EM cluster veto
616  if(em2 != nullptr){
617  if(em2->pt()/Gaudi::Units::GeV > 25.){
618  ATH_MSG_DEBUG("Event rejected due to second EM cluster w/ pT > 25 GeV");
619  selected++;
620  }
621  }
622  return selected;
623 }
624 
625 double IDPerfMonWenu::InvMass(const xAOD::CaloCluster* EM1, const xAOD::CaloCluster* EM2) const {
626  if (EM1 == nullptr || EM2 == nullptr) return -99.;
627  double invmass = 0.;
628  if (EM1->pt() != 0 && EM2->pt() != 0.) {
629  TLorentzVector particle1;
630  TLorentzVector particle2;
631  particle1.SetPtEtaPhiE(EM1->pt()/Gaudi::Units::GeV,EM1->eta(),EM1->phi(),EM1->e()/Gaudi::Units::GeV);
632  particle2.SetPtEtaPhiE(EM2->pt()/Gaudi::Units::GeV,EM2->eta(),EM2->phi(),EM2->e()/Gaudi::Units::GeV);
633  invmass = (particle1+particle2).Mag();
634  }
635  return invmass;
636 }
637 
638 double IDPerfMonWenu::InvMass(const xAOD::TrackParticle* trk1, const xAOD::TrackParticle* trk2) const {
639  if (trk1 == nullptr || trk2 == nullptr) return -99.;
640  double invmass = 0.;
641  if (trk1->pt() != 0 && trk2->pt() != 0.) {
642  TLorentzVector particle1;
643  TLorentzVector particle2;
644  particle1.SetPtEtaPhiE(trk1->pt()/Gaudi::Units::GeV,trk1->eta(),trk1->phi(),trk1->e()/Gaudi::Units::GeV);
645  particle2.SetPtEtaPhiE(trk2->pt()/Gaudi::Units::GeV,trk2->eta(),trk2->phi(),trk2->e()/Gaudi::Units::GeV);
646  invmass = (particle1+particle2).Mag();
647  }
648  return invmass;
649 }
650 
651 double IDPerfMonWenu::TransMass(const xAOD::CaloCluster* EM, const xAOD::MissingET* met) const {
652  if (EM == nullptr || met == nullptr) return -99.;
653  double transmass = 0.;
654  float dphi = signedDeltaPhi(EM->phi(),met->phi());
655  transmass = std::sqrt(2.*EM->et()*met->met()*(1.-std::cos(dphi)));
656  return transmass/Gaudi::Units::GeV;
657 
658 }
659 
660 double IDPerfMonWenu::TransMass(const xAOD::TrackParticle* track, const xAOD::MissingET* met) const {
661  if (track == nullptr || met == nullptr) return -99.;
662  double transmass = 0.;
663  float dphi = signedDeltaPhi(track->phi(),met->phi());
664  transmass = std::sqrt(2.*(track->p4().Et()/Gaudi::Units::GeV)*(met->met()/Gaudi::Units::GeV)*(1.-std::cos(dphi)));
665  return transmass;
666 }
667 
668 double IDPerfMonWenu::deltaR(const xAOD::CaloCluster* cluster, const xAOD::TrackParticle* track) const {
669  double dr =-999.;
670  if (cluster == nullptr || track == nullptr) return dr;
671  double deta = cluster->eta()-track->eta();
672  double dphi = cluster->phi()-track->phi();
673  if(std::abs(dphi) > M_PI) dphi = 2.*M_PI-std::abs(dphi);
674  dr = std::sqrt(deta*deta + dphi*dphi);
675  return dr;
676 
677 }
678 
679 double IDPerfMonWenu::signedDeltaPhi(double phi1, double phi2) const {
680  double phia=phi1;
681  if(phi1>Gaudi::Units::pi) phia=phi1-2.*Gaudi::Units::pi;
682  double phib=phi2;
683  if(phi2>Gaudi::Units::pi) phib=phi2-2.*Gaudi::Units::pi;
684  double dphi=phia-phib;
685  if(dphi>Gaudi::Units::pi) dphi-=2.*Gaudi::Units::pi;
686  if(dphi<-Gaudi::Units::pi) dphi+=2.*Gaudi::Units::pi;
687  return dphi;
688 }
689 
690 int IDPerfMonWenu::etaRegion(double eta) {
691  int region = -99;
692  if (std::abs(eta) <= 1.) region = barrel;
693  else if (eta > 1.) region = eca; // eca
694  else if (eta < -1.) region = ecc; // ecc
695  return region;
696 
697 }
698 
699 void IDPerfMonWenu::FillHistosPerCluster(const xAOD::CaloCluster* cluster, const xAOD::TrackParticle* track, int region, float dEta, float dPhi) {
700  if (not cluster) return;
701  if (region<0){
702  throw std::out_of_range("Region is negative in IDPerfMonWenu::FillHistosPerCluster");
703  }
704  // THERE IS A CLUSTER
705  if (region == incl) { // inclusive only
706  m_Wenu_eta[region]->Fill(cluster->eta());
707  m_Wenu_phi[region]->Fill(cluster->phi());
708  // match in eta and phi separately and make dEta and dPhi plots
709  if (dEta < 1.0e+20) {
710  m_Wenu_deta[region]->Fill(dEta);
711  if (std::abs(dEta) < 0.05) { // calculate mean only for those in matching window
712  m_Wenu_deta_vs_eta[region]->Fill(cluster->eta(),dEta);
713  m_Wenu_deta_vs_phi[region]->Fill(cluster->phi(),dEta);
714  m_Wenu_absdeta_vs_eta[region]->Fill(cluster->eta(),std::abs(dEta));
715  m_Wenu_absdeta_vs_phi[region]->Fill(cluster->phi(),std::abs(dEta));
716  }
717  }
718  if (dPhi < 1.0e+20) {
719  m_Wenu_dphi[region]->Fill(dPhi);
720  if (std::abs(dPhi) < 0.1) { // calculate mean only for those in matching window
721  m_Wenu_dphi_vs_eta[region]->Fill(cluster->eta(),dPhi);
722  m_Wenu_dphi_vs_phi[region]->Fill(cluster->phi(),dPhi);
723  m_Wenu_absdphi_vs_eta[region]->Fill(cluster->eta(),std::abs(dPhi));
724  m_Wenu_absdphi_vs_phi[region]->Fill(cluster->phi(),std::abs(dPhi));
725  }
726  }
727 
728  } // end inclusive only
729 
730  if (track == nullptr) return;
731  // TRACK-MATCHED
732  float eoverp = 0.;
733  float track_p = track->pt()*std::cosh(track->eta());
734  if (track_p != 0.) eoverp = cluster->e()/track_p;
735  m_Wenu_Eop[region]->Fill(eoverp);
736  if (track->charge() == 1.) {
737  m_Wenu_Eop_plus[region]->Fill(eoverp);
738  }
739  else if (track->charge() == -1.) {
740  m_Wenu_Eop_minus[region]->Fill(eoverp);
741  }
742  if (region == incl) { // inclusive only
743  m_Wenu_trackmatched_eta[region]->Fill(cluster->eta());
744  m_Wenu_trackmatched_phi[region]->Fill(cluster->phi());
745  if (eoverp > m_eoverp_tight_min && eoverp < m_eoverp_tight_max) {
746  m_Wenu_meanEop_vs_p[region]->Fill(track_p/Gaudi::Units::GeV,eoverp);
747  m_Wenu_meanEop_vs_invp[region]->Fill(1./(track_p/Gaudi::Units::GeV),eoverp);
748  m_Wenu_meanEop_vs_E[region]->Fill(cluster->e()/Gaudi::Units::GeV,eoverp);
749  m_Wenu_meanEop_vs_chargedp[region]->Fill(double(track->charge())*track_p/Gaudi::Units::GeV,eoverp);
750  m_Wenu_meanEop_vs_chargedE[region]->Fill(double(track->charge())*cluster->e()/Gaudi::Units::GeV,eoverp);
751  m_Wenu_meanEop_vs_phi[region]->Fill(track->phi(),eoverp);
752  m_Wenu_meanEop_vs_eta[region]->Fill(track->eta(),eoverp);
753  }
754  if (track->charge() == 1.) {
755  if (eoverp > m_eoverp_tight_min && eoverp < m_eoverp_tight_max) {
756  m_Wenu_meanEop_vs_p_plus[region]->Fill(track_p/Gaudi::Units::GeV,eoverp);
757  m_Wenu_meanEop_vs_invp_plus[region]->Fill(1./(track_p/Gaudi::Units::GeV),eoverp);
758  m_Wenu_meanEop_vs_E_plus[region]->Fill(cluster->e()/Gaudi::Units::GeV,eoverp);
759  m_Wenu_meanEop_vs_phi_plus[region]->Fill(track->phi(),eoverp);
760  m_Wenu_meanEop_vs_eta_plus[region]->Fill(track->eta(),eoverp);
761  }
762  }
763  else if (track->charge() == -1.) {
764  if (eoverp > m_eoverp_tight_min && eoverp < m_eoverp_tight_max) {
765  m_Wenu_meanEop_vs_p_minus[region]->Fill(track_p/Gaudi::Units::GeV,eoverp);
766  m_Wenu_meanEop_vs_invp_minus[region]->Fill(1./(track_p/Gaudi::Units::GeV),eoverp);
767  m_Wenu_meanEop_vs_E_minus[region]->Fill(cluster->e()/Gaudi::Units::GeV,eoverp);
768  m_Wenu_meanEop_vs_phi_minus[region]->Fill(track->phi(),eoverp);
769  m_Wenu_meanEop_vs_eta_minus[region]->Fill(track->eta(),eoverp);
770  }
771  }
772  if (eoverp < m_eoverp_standard_max && eoverp > m_eoverp_standard_min) {
773  m_Wenu_trackmatched_Eopmatched_eta[region]->Fill(cluster->eta());
774  m_Wenu_trackmatched_Eopmatched_phi[region]->Fill(cluster->phi());
775  }
776  if (eoverp < m_eoverp_tight_max && eoverp > m_eoverp_tight_min) {
777  m_Wenu_trackmatched_tightEopmatched_eta[region]->Fill(cluster->eta());
778  m_Wenu_trackmatched_tightEopmatched_phi[region]->Fill(cluster->phi());
779  }
780  if (eoverp > m_eoverp_tight_min && eoverp < 1.) {
781  m_Wenu_Eop_lt1_vs_eta[region]->Fill(cluster->eta());
782  m_Wenu_Eop_lt1_vs_phi[region]->Fill(cluster->phi());
783  m_Wenu_Eop_lt1_gt1[region]->Fill(0.75);
784  }
785  else if (eoverp > 1. && eoverp < m_eoverp_tight_max) {
786  m_Wenu_Eop_gt1_vs_eta[region]->Fill(cluster->eta());
787  m_Wenu_Eop_gt1_vs_phi[region]->Fill(cluster->phi());
788  m_Wenu_Eop_lt1_gt1[region]->Fill(1.25);
789  }
790  if (eoverp > 0.5 && eoverp < 2.5) m_Wenu_Eop_05_25[region]->Fill(0.5);
791  if (eoverp > 1.5 && eoverp < 2.5) m_Wenu_Eop_15_25[region]->Fill(0.5);
792 
793  } // end inclusive only
794 
795 }
IDPerfMonWenu::m_histosBooked
int m_histosBooked
Definition: IDPerfMonWenu.h:80
PixelID.h
This is an Identifier helper class for the Pixel subdetector. This class is a factory for creating co...
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
IDPerfMonWenu::m_tracksName
std::string m_tracksName
Definition: IDPerfMonWenu.h:164
IDPerfMonWenu::deltaR
double deltaR(const xAOD::CaloCluster *cluster, const xAOD::TrackParticle *track) const
Definition: IDPerfMonWenu.cxx:668
egammaPIDdefsObs.h
DiTauMassTools::TauTypes::lh
@ lh
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:49
IDPerfMonWenu::m_LHTool2015
std::unique_ptr< AsgElectronLikelihoodTool > m_LHTool2015
Definition: IDPerfMonWenu.h:181
SCT_ID.h
This is an Identifier helper class for the SCT subdetector. This class is a factory for creating comp...
IDPerfMonWenu::incl
@ incl
Definition: IDPerfMonWenu.h:82
IDPerfMonWenu::etaRegion
int etaRegion(double eta)
Definition: IDPerfMonWenu.cxx:690
IDPerfMonWenu::m_Wenu_transmass_sel
TH1F * m_Wenu_transmass_sel
Definition: IDPerfMonWenu.h:90
taskman.configFile
configFile
Definition: taskman.py:311
IDPerfMonWenu::m_triggerChainName
std::string m_triggerChainName
Definition: IDPerfMonWenu.h:170
IDPerfMonWenu::m_Wenu_trackmatched_eta
std::vector< TH1F * > m_Wenu_trackmatched_eta
Definition: IDPerfMonWenu.h:110
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
IDPerfMonWenu::makeEffHisto
void makeEffHisto(TH1F *h_num, TH1F *h_denom, TH1F *h_eff)
Definition: IDPerfMonWenu.cxx:492
TRT_DetectorManager.h
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
IDPerfMonWenu::m_Wenu_meanEop_vs_phi_plus
std::vector< TProfile * > m_Wenu_meanEop_vs_phi_plus
Definition: IDPerfMonWenu.h:136
ManagedMonitorToolBase
Provides functionality for users to implement and save histograms, ntuples, and summary data,...
Definition: ManagedMonitorToolBase.h:74
IDPerfMonWenu::InvMass
double InvMass(const xAOD::CaloCluster *EM1, const xAOD::CaloCluster *EM2) const
Definition: IDPerfMonWenu.cxx:625
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
IDPerfMonWenu::m_Wenu_absdeta_vs_phi
std::vector< TProfile * > m_Wenu_absdeta_vs_phi
Definition: IDPerfMonWenu.h:103
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
IDPerfMonWenu::m_Wenu_phi
std::vector< TH1F * > m_Wenu_phi
Definition: IDPerfMonWenu.h:98
IDPerfMonWenu::m_Wenu_absdphi_vs_eta
std::vector< TProfile * > m_Wenu_absdphi_vs_eta
Definition: IDPerfMonWenu.h:107
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
IDPerfMonWenu::m_Wenu_Eop_05_25
std::vector< TH1F * > m_Wenu_Eop_05_25
Definition: IDPerfMonWenu.h:157
Ringer::EM2
@ EM2
Definition: CaloRingsDefs.h:48
IDPerfMonWenu::m_Wenu_meanEop_vs_chargedp
std::vector< TProfile * > m_Wenu_meanEop_vs_chargedp
Definition: IDPerfMonWenu.h:129
IDPerfMonWenu::m_Wenu_clus_pt
TH1F * m_Wenu_clus_pt
Definition: IDPerfMonWenu.h:93
IDPerfMonWenu::m_Wenu_deta_vs_eta
std::vector< TProfile * > m_Wenu_deta_vs_eta
Definition: IDPerfMonWenu.h:100
TRT_ID.h
This is an Identifier helper class for the TRT subdetector. This class is a factory for creating comp...
M_PI
#define M_PI
Definition: ActiveFraction.h:11
IDPerfMonWenu::electronTrackMatch
const xAOD::TrackParticle * electronTrackMatch(const xAOD::TrackParticleContainer *tracks, const xAOD::CaloCluster *cluster, double dEta=0.05, double dPhi=0.1) const
Definition: IDPerfMonWenu.cxx:564
IDPerfMonWenu::m_Wenu_dphi_vs_eta
std::vector< TProfile * > m_Wenu_dphi_vs_eta
Definition: IDPerfMonWenu.h:105
IDPerfMonWenu::m_Wenu_meanEop_vs_eta
std::vector< TProfile * > m_Wenu_meanEop_vs_eta
Definition: IDPerfMonWenu.h:132
IDPerfMonWenu::m_Wenu_meanEop_vs_phi
std::vector< TProfile * > m_Wenu_meanEop_vs_phi
Definition: IDPerfMonWenu.h:131
IDPerfMonWenu::m_electronsName
std::string m_electronsName
Definition: IDPerfMonWenu.h:165
IDPerfMonWenu::initialize
virtual StatusCode initialize()
Definition: IDPerfMonWenu.cxx:94
IDPerfMonWenu::m_Wenu_meanEop_vs_E_plus
std::vector< TProfile * > m_Wenu_meanEop_vs_E_plus
Definition: IDPerfMonWenu.h:135
SiClusterOnTrack.h
IDPerfMonWenu::m_Wenu_trackmatch_eff_vs_phi
std::vector< TH1F * > m_Wenu_trackmatch_eff_vs_phi
Definition: IDPerfMonWenu.h:117
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
IDPerfMonWenu::m_Wenu_tightEopmatch_eff_vs_phi
std::vector< TH1F * > m_Wenu_tightEopmatch_eff_vs_phi
Definition: IDPerfMonWenu.h:121
IDPerfMonWenu::m_Wenu_Eopdiff_vs_E
std::vector< TProfile * > m_Wenu_Eopdiff_vs_E
Definition: IDPerfMonWenu.h:147
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
IdDictManager.h
IDPerfMonWenu::m_Wenu_Eopdiff_vs_invp
std::vector< TProfile * > m_Wenu_Eopdiff_vs_invp
Definition: IDPerfMonWenu.h:146
IDPerfMonWenu::m_Wenu_meanEop_vs_phi_minus
std::vector< TProfile * > m_Wenu_meanEop_vs_phi_minus
Definition: IDPerfMonWenu.h:141
IDPerfMonWenu::ecc
@ ecc
Definition: IDPerfMonWenu.h:82
IDPerfMonWenu::m_region_strings
std::vector< std::string > m_region_strings
Definition: IDPerfMonWenu.h:83
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
IDPerfMonWenu::m_Wenu_trackmatch_eff_vs_eta
std::vector< TH1F * > m_Wenu_trackmatch_eff_vs_eta
Definition: IDPerfMonWenu.h:116
IDPerfMonWenu::m_Nevents
TH1F * m_Nevents
Definition: IDPerfMonWenu.h:87
pi
#define pi
Definition: TileMuonFitter.cxx:65
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
IDPerfMonWenu::m_Wenu_meanEop_vs_eta_minus
std::vector< TProfile * > m_Wenu_meanEop_vs_eta_minus
Definition: IDPerfMonWenu.h:142
IDPerfMonWenu::m_Wenu_Eop_gt1_vs_phi
std::vector< TH1F * > m_Wenu_Eop_gt1_vs_phi
Definition: IDPerfMonWenu.h:153
IDPerfMonWenu::bookHistograms
virtual StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition: IDPerfMonWenu.cxx:135
IDPerfMonWenu::m_Wenu_Eop_15_25
std::vector< TH1F * > m_Wenu_Eop_15_25
Definition: IDPerfMonWenu.h:158
AthenaMonManager::environment
static Environment_t environment()
Returns the running environment of the monitoring application to help ManagedMonitorToolBase objects ...
Definition: AthenaMonManager.cxx:321
IDPerfMonWenu::m_metName
std::string m_metName
Definition: IDPerfMonWenu.h:169
IDPerfMonWenu::TransMass
double TransMass(const xAOD::CaloCluster *EM, const xAOD::MissingET *met) const
Definition: IDPerfMonWenu.cxx:651
Egamma.h
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition: ManagedMonitorToolBase.h:138
IDPerfMonWenu::m_emclustersName
std::string m_emclustersName
Definition: IDPerfMonWenu.h:168
IDPerfMonWenu::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: IDPerfMonWenu.cxx:402
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
IDPerfMonWenu::m_Wenu_Eop_gt1_vs_eta
std::vector< TH1F * > m_Wenu_Eop_gt1_vs_eta
Definition: IDPerfMonWenu.h:152
IDPerfMonWenu::m_VxPrimContainerName
std::string m_VxPrimContainerName
Definition: IDPerfMonWenu.h:167
IDPerfMonWenu::m_Wenu_Eop_lt1_vs_eta
std::vector< TH1F * > m_Wenu_Eop_lt1_vs_eta
Definition: IDPerfMonWenu.h:150
met
Definition: IMETSignificance.h:24
IDPerfMonWenu::m_Wenu_dphi
std::vector< TH1F * > m_Wenu_dphi
Definition: IDPerfMonWenu.h:104
IDPerfMonWenu::m_Wenu_trackmatched_phi
std::vector< TH1F * > m_Wenu_trackmatched_phi
Definition: IDPerfMonWenu.h:111
IDPerfMonWenu::eca
@ eca
Definition: IDPerfMonWenu.h:82
IDPerfMonWenu::m_Wenu_Eopdiff_vs_phi
std::vector< TProfile * > m_Wenu_Eopdiff_vs_phi
Definition: IDPerfMonWenu.h:148
IDPerfMonWenu::FillHistosPerCluster
void FillHistosPerCluster(const xAOD::CaloCluster *cluster, const xAOD::TrackParticle *track, int region, float dEta, float dPhi)
Definition: IDPerfMonWenu.cxx:699
Ringer::EM
@ EM
Definition: CaloRingsDefs.h:19
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:669
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
CaloCluster.h
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
PerfMonServices::ELECTRON_COLLECTION
@ ELECTRON_COLLECTION
Definition: PerfMonServices.h:49
Photon.h
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
IDPerfMonWenu::m_Wenu_dphi_vs_phi
std::vector< TProfile * > m_Wenu_dphi_vs_phi
Definition: IDPerfMonWenu.h:106
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:530
IDPerfMonWenu::m_Wenu_meanEop_vs_invp
std::vector< TProfile * > m_Wenu_meanEop_vs_invp
Definition: IDPerfMonWenu.h:127
IDPerfMonWenu::m_Wenu_meanEop_vs_p
std::vector< TProfile * > m_Wenu_meanEop_vs_p
Definition: IDPerfMonWenu.h:126
IDPerfMonWenu::m_doIDCuts
bool m_doIDCuts
Definition: IDPerfMonWenu.h:179
IDPerfMonWenu::m_Wenu_deta
std::vector< TH1F * > m_Wenu_deta
Definition: IDPerfMonWenu.h:99
covarianceTool.title
title
Definition: covarianceTool.py:542
TrackCollection.h
IDPerfMonWenu::m_Wenu_Eop
std::vector< TH1F * > m_Wenu_Eop
Definition: IDPerfMonWenu.h:123
IDPerfMonWenu::m_Wenu_meanEop_vs_p_plus
std::vector< TProfile * > m_Wenu_meanEop_vs_p_plus
Definition: IDPerfMonWenu.h:133
TCS::MET
@ MET
Definition: Trigger/TrigT1/L1Topo/L1TopoCommon/L1TopoCommon/Types.h:16
test_pyathena.parent
parent
Definition: test_pyathena.py:15
IDPerfMonWenu::m_Wenu_Eopdiff_vs_p
std::vector< TProfile * > m_Wenu_Eopdiff_vs_p
Definition: IDPerfMonWenu.h:145
xAOD::MissingET_v1
Principal data object for Missing ET.
Definition: MissingET_v1.h:25
IDPerfMonWenu::electronTrackMatchPhi
double electronTrackMatchPhi(const xAOD::TrackParticleContainer *tracks, const xAOD::CaloCluster *cluster, double dPhi=0.1) const
Definition: IDPerfMonWenu.cxx:594
AthenaMonManager.h
AthenaMonManager::user
@ user
Definition: AthenaMonManager.h:49
IDPerfMonWenu::m_photonsName
std::string m_photonsName
Definition: IDPerfMonWenu.h:166
run
Definition: run.py:1
IDPerfMonWenu::m_metRefFinalName
std::string m_metRefFinalName
Definition: IDPerfMonWenu.h:171
IDPerfMonWenu::~IDPerfMonWenu
virtual ~IDPerfMonWenu()
Definition: IDPerfMonWenu.cxx:92
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
TH2
Definition: rootspy.cxx:373
IDPerfMonWenu::IDPerfMonWenu
IDPerfMonWenu(const std::string &type, const std::string &name, const IInterface *parent)
Definition: IDPerfMonWenu.cxx:70
IDPerfMonWenu::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: IDPerfMonWenu.cxx:496
IDPerfMonWenu::m_Wenu_Eop_lt1_gt1
std::vector< TH1F * > m_Wenu_Eop_lt1_gt1
Definition: IDPerfMonWenu.h:143
egammaParamDefs.h
IDPerfMonWenu::m_rejectSecondCluster
bool m_rejectSecondCluster
Definition: IDPerfMonWenu.h:177
IDPerfMonWenu::m_Wenu_absdphi_vs_phi
std::vector< TProfile * > m_Wenu_absdphi_vs_phi
Definition: IDPerfMonWenu.h:108
IDPerfMonWenu::m_Wenu_Eopdiff
std::vector< TH1F * > m_Wenu_Eopdiff
Definition: IDPerfMonWenu.h:144
IDPerfMonWenu::Nregions
@ Nregions
Definition: IDPerfMonWenu.h:82
xAOD::CaloCluster_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle (negative for negative-energy clusters)
Definition: CaloCluster_v1.cxx:247
xAOD::MissingETContainer_v1
Container for xAOD::MissingET_v1 objects.
Definition: MissingETContainer_v1.h:21
MissingET.h
IDPerfMonWenu::m_Wenu_frac_Eop_lt1_vs_phi
std::vector< TH1F * > m_Wenu_frac_Eop_lt1_vs_phi
Definition: IDPerfMonWenu.h:155
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
IDPerfMonWenu::m_Wenu_trackmatched_Eopmatched_eta
std::vector< TH1F * > m_Wenu_trackmatched_Eopmatched_eta
Definition: IDPerfMonWenu.h:112
IDPerfMonWenu.h
IDPerfMonWenu::m_Wenu_meanEop_vs_E_minus
std::vector< TProfile * > m_Wenu_meanEop_vs_E_minus
Definition: IDPerfMonWenu.h:140
IDPerfMonWenu::m_eoverp_tight_min
double m_eoverp_tight_min
Definition: IDPerfMonWenu.h:172
SiCluster.h
TProfile
Definition: rootspy.cxx:515
xAOD::TrackParticle_v1::e
virtual double e() const override final
The total energy of the particle.
Definition: TrackParticle_v1.cxx:109
IDPerfMonWenu::signedDeltaPhi
double signedDeltaPhi(double phi1, double phi2) const
Definition: IDPerfMonWenu.cxx:679
IDPerfMonWenu::m_Wenu_meanEop_vs_invp_plus
std::vector< TProfile * > m_Wenu_meanEop_vs_invp_plus
Definition: IDPerfMonWenu.h:134
LocalParameters.h
IDPerfMonWenu::m_Wenu_meanEop_vs_invp_minus
std::vector< TProfile * > m_Wenu_meanEop_vs_invp_minus
Definition: IDPerfMonWenu.h:139
IDPerfMonWenu::m_Wenu_trk_transmass_sel
TH1F * m_Wenu_trk_transmass_sel
Definition: IDPerfMonWenu.h:91
IDPerfMonWenu::barrel
@ barrel
Definition: IDPerfMonWenu.h:82
IDPerfMonWenu::m_Wenu_eta
std::vector< TH1F * > m_Wenu_eta
Definition: IDPerfMonWenu.h:97
IDPerfMonWenu::m_Wenu_trackmatched_tightEopmatched_phi
std::vector< TH1F * > m_Wenu_trackmatched_tightEopmatched_phi
Definition: IDPerfMonWenu.h:115
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
IDPerfMonWenu::m_Wenu_Eop_lt1_vs_phi
std::vector< TH1F * > m_Wenu_Eop_lt1_vs_phi
Definition: IDPerfMonWenu.h:151
IDPerfMonWenu::m_Wenu_Eopdiff_vs_eta
std::vector< TProfile * > m_Wenu_Eopdiff_vs_eta
Definition: IDPerfMonWenu.h:149
TH1F
Definition: rootspy.cxx:320
IDPerfMonWenu::isWenu
int isWenu(const xAOD::CaloCluster *em, const xAOD::CaloCluster *em2, double met) const
Definition: IDPerfMonWenu.cxx:610
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
IDPerfMonWenu::m_Wenu_trackmatched_tightEopmatched_eta
std::vector< TH1F * > m_Wenu_trackmatched_tightEopmatched_eta
Definition: IDPerfMonWenu.h:114
ManagedMonitorToolBase::endOfRunFlag
bool endOfRunFlag() const
Definition: ManagedMonitorToolBase.h:859
IDPerfMonWenu::m_Wenu_trackmatched_Eopmatched_phi
std::vector< TH1F * > m_Wenu_trackmatched_Eopmatched_phi
Definition: IDPerfMonWenu.h:113
IDPerfMonWenu::getLeadingEMcluster
const xAOD::CaloCluster * getLeadingEMcluster(const xAOD::CaloClusterContainer *clusters, const xAOD::CaloCluster *omitCluster=0) const
Definition: IDPerfMonWenu.cxx:524
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TH1
Definition: rootspy.cxx:268
DEBUG
#define DEBUG
Definition: page_access.h:11
plotBeamSpotMon.mon
mon
Definition: plotBeamSpotMon.py:67
IDPerfMonWenu::m_Wenu_meanEop_vs_chargedE
std::vector< TProfile * > m_Wenu_meanEop_vs_chargedE
Definition: IDPerfMonWenu.h:130
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
IDPerfMonWenu::m_Wenu_Eopmatch_eff_vs_phi
std::vector< TH1F * > m_Wenu_Eopmatch_eff_vs_phi
Definition: IDPerfMonWenu.h:119
IDPerfMonWenu::m_Wenu_absdeta_vs_eta
std::vector< TProfile * > m_Wenu_absdeta_vs_eta
Definition: IDPerfMonWenu.h:102
IDPerfMonWenu::m_Wenu_Eop_plus
std::vector< TH1F * > m_Wenu_Eop_plus
Definition: IDPerfMonWenu.h:124
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
IDPerfMonWenu::m_eoverp_standard_min
double m_eoverp_standard_min
Definition: IDPerfMonWenu.h:174
LArG4GenerateShowerLib.nevents
nevents
Definition: LArG4GenerateShowerLib.py:19
Electron.h
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
IDPerfMonWenu::m_Wenu_Eopmatch_eff_vs_eta
std::vector< TH1F * > m_Wenu_Eopmatch_eff_vs_eta
Definition: IDPerfMonWenu.h:118
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
IDPerfMonWenu::m_Wenu_meanEop_vs_eta_plus
std::vector< TProfile * > m_Wenu_meanEop_vs_eta_plus
Definition: IDPerfMonWenu.h:137
IDPerfMonWenu::m_Wenu_deta_vs_phi
std::vector< TProfile * > m_Wenu_deta_vs_phi
Definition: IDPerfMonWenu.h:101
IDPerfMonWenu::m_Wenu_met_sel
TH1F * m_Wenu_met_sel
Definition: IDPerfMonWenu.h:89
FitQuality.h
plotBeamSpotCompare.histo
histo
Definition: plotBeamSpotCompare.py:415
TauGNNUtils::Variables::Track::dEta
bool dEta(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:525
Ringer::EM1
@ EM1
Definition: CaloRingsDefs.h:47
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
IDPerfMonWenu::m_Wenu_meanEop_vs_p_minus
std::vector< TProfile * > m_Wenu_meanEop_vs_p_minus
Definition: IDPerfMonWenu.h:138
IDPerfMonWenu::m_Wenu_Eop_minus
std::vector< TH1F * > m_Wenu_Eop_minus
Definition: IDPerfMonWenu.h:125
StoreGateSvc.h
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:26
MissingETContainer.h
IDPerfMonWenu::m_Wenu_frac_Eop_05_25_15_25
std::vector< TH1F * > m_Wenu_frac_Eop_05_25_15_25
Definition: IDPerfMonWenu.h:159
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
IDPerfMonWenu::RegisterHisto
void RegisterHisto(MonGroup &mon, TH1 *histo, bool doSumw2=false)
Definition: IDPerfMonWenu.cxx:381
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
IDPerfMonWenu::m_Wenu_frac_Eop_lt1_vs_eta
std::vector< TH1F * > m_Wenu_frac_Eop_lt1_vs_eta
Definition: IDPerfMonWenu.h:154
IDPerfMonWenu::m_Wenu_meanEop_vs_E
std::vector< TProfile * > m_Wenu_meanEop_vs_E
Definition: IDPerfMonWenu.h:128
IDPerfMonWenu::m_electronIDLevel
std::string m_electronIDLevel
Definition: IDPerfMonWenu.h:178
IDPerfMonWenu::m_eoverp_tight_max
double m_eoverp_tight_max
Definition: IDPerfMonWenu.h:173
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
IDPerfMonWenu::m_Wenu_trk_transmass_sel_scaled
TH1F * m_Wenu_trk_transmass_sel_scaled
Definition: IDPerfMonWenu.h:92
IDPerfMonWenu::electronTrackMatchEta
double electronTrackMatchEta(const xAOD::TrackParticleContainer *tracks, const xAOD::CaloCluster *cluster, double dEta=0.05) const
Definition: IDPerfMonWenu.cxx:579
IDPerfMonWenu::m_Wenu_tightEopmatch_eff_vs_eta
std::vector< TH1F * > m_Wenu_tightEopmatch_eff_vs_eta
Definition: IDPerfMonWenu.h:120
ServiceHandle< StoreGateSvc >
ManagedMonitorToolBase::newRunFlag
bool newRunFlag() const
Definition: ManagedMonitorToolBase.h:854
Generated on Tue Jul 2 2024 21:17:06 for ATLAS Offline Software by   doxygen 1.8.18