ATLAS Offline Software
TrigMETMonitorAlgorithm.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 #include "LArRecEvent/LArEventBitInfo.h"
5 #include "TrigMETMonitorAlgorithm.h"
6 #include "TrigDecisionTool/TrigDecisionTool.h"
7 #include <TVector3.h>
8 #include <cmath>
9 
10 TrigMETMonitorAlgorithm::TrigMETMonitorAlgorithm( const std::string& name, ISvcLocator* pSvcLocator )
11  : AthMonitorAlgorithm(name,pSvcLocator)
12 {
13 }
14 
15 
16 TrigMETMonitorAlgorithm::~TrigMETMonitorAlgorithm() {}
17 
18 
19 StatusCode TrigMETMonitorAlgorithm::initialize() {
20  ATH_CHECK( m_EventInfoKey.initialize() );
21  ATH_CHECK( m_offline_met_key.initialize() );
22  ATH_CHECK( m_hlt_electron_key.initialize() );
23  ATH_CHECK( m_hlt_muon_key.initialize() );
24  ATH_CHECK( m_topoclusters_key.initialize() );
25  ATH_CHECK( m_tracks_key.initialize() );
26  ATH_CHECK( m_vertex_key.initialize() );
27  ATH_CHECK( m_offline_vertex_key.initialize() );
28  ATH_CHECK( m_lvl1_roi_key.initialize() );
29  ATH_CHECK( m_l1_jFexMet_key.initialize() );
30  ATH_CHECK( m_l1_jFexSumEt_key.initialize() );
31  ATH_CHECK( m_l1_gFexJwojScalar_key.initialize() );
32  ATH_CHECK( m_l1_gFexJwojMETComponents_key.initialize() );
33  ATH_CHECK( m_l1_gFexJwojMHTComponents_key.initialize() );
34  ATH_CHECK( m_l1_gFexJwojMSTComponents_key.initialize() );
35  ATH_CHECK( m_l1_gFexNCMETScalar_key.initialize() );
36  ATH_CHECK( m_l1_gFexNCMETComponents_key.initialize() );
37  ATH_CHECK( m_l1_gFexRhoMETScalar_key.initialize() );
38  ATH_CHECK( m_l1_gFexRhoMETComponents_key.initialize() );
39  ATH_CHECK( m_hlt_cell_met_key.initialize() );
40  ATH_CHECK( m_hlt_mht_met_key.initialize() );
41  ATH_CHECK( m_hlt_tc_met_key.initialize() );
42  ATH_CHECK( m_hlt_tc_em_met_key.initialize() );
43  ATH_CHECK( m_hlt_tcpufit_met_key.initialize() );
44  ATH_CHECK( m_hlt_tcpufit_sig30_met_key.initialize() );
45  ATH_CHECK( m_hlt_trkmht_met_key.initialize() );
46  ATH_CHECK( m_hlt_pfsum_met_key.initialize() );
47  ATH_CHECK( m_hlt_pfopufit_met_key.initialize() );
48  ATH_CHECK( m_hlt_pfopufit_sig30_met_key.initialize() );
49  ATH_CHECK( m_hlt_cvfpufit_met_key.initialize() );
50  ATH_CHECK( m_hlt_mhtpufit_pf_met_key.initialize() );
51  ATH_CHECK( m_hlt_mhtpufit_em_met_key.initialize() );
52  ATH_CHECK( m_hlt_met_nn_key.initialize() );
53  ATH_CHECK( m_hlt_pfsum_cssk_met_key.initialize() );
54  ATH_CHECK( m_hlt_pfsum_vssk_met_key.initialize() );
55 
56  return AthMonitorAlgorithm::initialize();
57 }
58 
59 
60 StatusCode TrigMETMonitorAlgorithm::fillHistograms( const EventContext& ctx ) const {
61  using namespace Monitored;
62 
63 
64  if(m_trigDecTool->ExperimentalAndExpertMethods().isHLTTruncated()){
65  ATH_MSG_WARNING("HLTResult truncated, skip trigger analysis");
66  return StatusCode::SUCCESS;
67  } // ATR-31454
68 
69 
70  // access event info container
71  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_EventInfoKey, ctx);
72  if (! eventInfo.isValid() ){
73  ATH_MSG_DEBUG("Container "<< eventInfo << " does not exist");
74  }
75 
76  // access lepton containers
77  SG::ReadHandle<xAOD::ElectronContainer> hlt_electron_cont(m_hlt_electron_key, ctx);
78  if (! hlt_electron_cont.isValid() ) {
79  ATH_MSG_DEBUG("Container "<< m_hlt_electron_key << " does not exist");
80  }
81 
82  SG::ReadHandle<xAOD::MuonContainer> hlt_muon_cont(m_hlt_muon_key, ctx);
83  if (! hlt_muon_cont.isValid() ) {
84  ATH_MSG_DEBUG("Container "<< m_hlt_muon_key << " does not exist");
85  }
86 
87  // access topoclusters container
88  SG::ReadHandle<xAOD::CaloClusterContainer> hlt_topoclusters_cont(m_topoclusters_key, ctx);
89  if (! hlt_topoclusters_cont.isValid() ) {
90  ATH_MSG_DEBUG("Container "<< m_topoclusters_key << " does not exist");
91  }
92 
93  // access tracks container
94  SG::ReadHandle<xAOD::TrackParticleContainer> hlt_tracks_cont(m_tracks_key, ctx);
95  if (! hlt_tracks_cont.isValid() ) {
96  ATH_MSG_DEBUG("Container "<< m_tracks_key << " does not exist");
97  }
98 
99  // access vertex container
100  SG::ReadHandle<xAOD::VertexContainer> hlt_vertex_cont(m_vertex_key, ctx);
101  if (! hlt_vertex_cont.isValid() ) {
102  ATH_MSG_DEBUG("Container "<< m_vertex_key << " does not exist");
103  }
104 
105  SG::ReadHandle<xAOD::VertexContainer> offline_vertex_cont(m_offline_vertex_key, ctx);
106  if (! offline_vertex_cont.isValid() ) {
107  ATH_MSG_DEBUG("Container "<< m_offline_vertex_key << " does not exist");
108  }
109 
110  // access offline met containers
111  SG::ReadHandle<xAOD::MissingETContainer> offline_met_cont(m_offline_met_key, ctx);
112  if (! offline_met_cont.isValid() ) {
113  ATH_MSG_DEBUG("Container "<< m_offline_met_key << " does not exist");
114  }
115 
116  // access L1 met containers
117  SG::ReadHandle<xAOD::EnergySumRoI> l1_roi_cont(m_lvl1_roi_key, ctx);
118  if (! l1_roi_cont.isValid() ) {
119  ATH_MSG_DEBUG("Container "<< m_lvl1_roi_key << " does not exist");
120  }
121 
122  // access L1 Fex met containers
123  SG::ReadHandle<xAOD::jFexMETRoIContainer> l1_jFexMet_cont(m_l1_jFexMet_key, ctx);
124  if (! l1_jFexMet_cont.isValid() ) {
125  ATH_MSG_DEBUG("Container "<< m_l1_jFexMet_key << " does not exist");
126  }
127  SG::ReadHandle<xAOD::jFexSumETRoIContainer> l1_jFexSumEt_cont(m_l1_jFexSumEt_key, ctx);
128  if (! l1_jFexSumEt_cont.isValid() ) {
129  ATH_MSG_DEBUG("Container "<< m_l1_jFexSumEt_key << " does not exist");
130  }
131  SG::ReadHandle<xAOD::gFexGlobalRoIContainer> l1_gFexJwojScalar_cont(m_l1_gFexJwojScalar_key, ctx);
132  if (! l1_gFexJwojScalar_cont.isValid() ) {
133  ATH_MSG_DEBUG("Container "<< m_l1_gFexJwojScalar_key << " does not exist");
134  }
135  SG::ReadHandle<xAOD::gFexGlobalRoIContainer> l1_gFexJwojMETComponents_cont(m_l1_gFexJwojMETComponents_key, ctx);
136  if (! l1_gFexJwojMETComponents_cont.isValid() ) {
137  ATH_MSG_DEBUG("Container "<< m_l1_gFexJwojMETComponents_key << " does not exist");
138  }
139  SG::ReadHandle<xAOD::gFexGlobalRoIContainer> l1_gFexJwojMHTComponents_cont(m_l1_gFexJwojMHTComponents_key, ctx);
140  if (! l1_gFexJwojMHTComponents_cont.isValid() ) {
141  ATH_MSG_DEBUG("Container "<< m_l1_gFexJwojMHTComponents_key << " does not exist");
142  }
143  SG::ReadHandle<xAOD::gFexGlobalRoIContainer> l1_gFexJwojMSTComponents_cont(m_l1_gFexJwojMSTComponents_key, ctx);
144  if (! l1_gFexJwojMSTComponents_cont.isValid() ) {
145  ATH_MSG_DEBUG("Container "<< m_l1_gFexJwojMSTComponents_key << " does not exist");
146  }
147  SG::ReadHandle<xAOD::gFexGlobalRoIContainer> l1_gFexNCMETScalar_cont(m_l1_gFexNCMETScalar_key, ctx);
148  if (! l1_gFexNCMETScalar_cont.isValid() ) {
149  ATH_MSG_DEBUG("Container "<< m_l1_gFexNCMETScalar_key << " does not exist");
150  }
151  SG::ReadHandle<xAOD::gFexGlobalRoIContainer> l1_gFexNCMETComponents_cont(m_l1_gFexNCMETComponents_key, ctx);
152  if (! l1_gFexNCMETComponents_cont.isValid() ) {
153  ATH_MSG_DEBUG("Container "<< m_l1_gFexNCMETComponents_key << " does not exist");
154  }
155  SG::ReadHandle<xAOD::gFexGlobalRoIContainer> l1_gFexRhoMETScalar_cont(m_l1_gFexRhoMETScalar_key, ctx);
156  if (! l1_gFexRhoMETScalar_cont.isValid() ) {
157  ATH_MSG_DEBUG("Container "<< m_l1_gFexRhoMETScalar_key << " does not exist");
158  }
159  SG::ReadHandle<xAOD::gFexGlobalRoIContainer> l1_gFexRhoMETComponents_cont(m_l1_gFexRhoMETComponents_key, ctx);
160  if (! l1_gFexRhoMETComponents_cont.isValid() ) {
161  ATH_MSG_DEBUG("Container "<< m_l1_gFexRhoMETComponents_key << " does not exist");
162  }
163 
164  // access HLT met containers
165  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_cell_met_cont(m_hlt_cell_met_key, ctx);
166  if (! hlt_cell_met_cont.isValid() ) {
167  ATH_MSG_DEBUG("Container "<< m_hlt_cell_met_key << " does not exist");
168  }
169 
170  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_mht_met_cont(m_hlt_mht_met_key, ctx);
171  if (! hlt_mht_met_cont.isValid() ) {
172  ATH_MSG_DEBUG("Container "<< m_hlt_mht_met_key << " does not exist");
173  }
174 
175  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_tc_met_cont(m_hlt_tc_met_key, ctx);
176  if (! hlt_tc_met_cont.isValid() ) {
177  ATH_MSG_DEBUG("Container "<< m_hlt_tc_met_key << " does not exist");
178  }
179 
180  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_tc_em_met_cont(m_hlt_tc_em_met_key, ctx);
181  if (! hlt_tc_em_met_cont.isValid() ) {
182  ATH_MSG_DEBUG("Container "<< m_hlt_tc_em_met_key << " does not exist");
183  }
184 
185  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_tcpufit_met_cont(m_hlt_tcpufit_met_key, ctx);
186  if (! hlt_tcpufit_met_cont.isValid() ) {
187  ATH_MSG_DEBUG("Container "<< m_hlt_tcpufit_met_key << " does not exist");
188  }
189 
190  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_tcpufit_sig30_met_cont(m_hlt_tcpufit_sig30_met_key, ctx);
191  if (! hlt_tcpufit_sig30_met_cont.isValid() ) {
192  ATH_MSG_DEBUG("Container "<< m_hlt_tcpufit_sig30_met_key << " does not exist");
193  }
194 
195  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_trkmht_met_cont(m_hlt_trkmht_met_key, ctx);
196  if (! hlt_trkmht_met_cont.isValid() ) {
197  ATH_MSG_DEBUG("Container "<< m_hlt_trkmht_met_key << " does not exist");
198  }
199 
200  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_pfsum_met_cont(m_hlt_pfsum_met_key, ctx);
201  if (! hlt_pfsum_met_cont.isValid() ) {
202  ATH_MSG_DEBUG("Container "<< m_hlt_pfsum_met_key << " does not exist");
203  }
204 
205  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_pfsum_cssk_met_cont(m_hlt_pfsum_cssk_met_key, ctx);
206  if (! hlt_pfsum_cssk_met_cont.isValid() ) {
207  ATH_MSG_DEBUG("Container "<< m_hlt_pfsum_cssk_met_key << " does not exist");
208  }
209 
210  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_pfsum_vssk_met_cont(m_hlt_pfsum_vssk_met_key, ctx);
211  if (! hlt_pfsum_vssk_met_cont.isValid() ) {
212  ATH_MSG_DEBUG("Container "<< m_hlt_pfsum_vssk_met_key << " does not exist");
213  }
214 
215  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_pfopufit_met_cont(m_hlt_pfopufit_met_key, ctx);
216  if (! hlt_pfopufit_met_cont.isValid() ) {
217  ATH_MSG_DEBUG("Container "<< m_hlt_pfopufit_met_key << " does not exist");
218  }
219 
220  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_pfopufit_sig30_met_cont(m_hlt_pfopufit_sig30_met_key, ctx);
221  if (! hlt_pfopufit_sig30_met_cont.isValid() ) {
222  ATH_MSG_DEBUG("Container "<< m_hlt_pfopufit_sig30_met_key << " does not exist");
223  }
224 
225  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_cvfpufit_met_cont(m_hlt_cvfpufit_met_key, ctx);
226  if (! hlt_cvfpufit_met_cont.isValid() ) {
227  ATH_MSG_DEBUG("Container "<< m_hlt_cvfpufit_met_key << " does not exist");
228  }
229 
230  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_mhtpufit_pf_met_cont(m_hlt_mhtpufit_pf_met_key, ctx);
231  if (! hlt_mhtpufit_pf_met_cont.isValid() ) {
232  ATH_MSG_DEBUG("Container "<< m_hlt_mhtpufit_pf_met_key << " does not exist");
233  }
234 
235  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_mhtpufit_em_met_cont(m_hlt_mhtpufit_em_met_key, ctx);
236  if (! hlt_mhtpufit_em_met_cont.isValid() ) {
237  ATH_MSG_DEBUG("Container "<< m_hlt_mhtpufit_em_met_key << " does not exist");
238  }
239 
240  SG::ReadHandle<xAOD::TrigMissingETContainer> hlt_met_nn_cont(m_hlt_met_nn_key, ctx);
241  if (! hlt_met_nn_cont.isValid() ) {
242  ATH_MSG_DEBUG("Container "<< m_hlt_met_nn_key << " does not exist");
243  }
244 
245  // define variables
246  auto act_IPBC = Monitored::Scalar<float>("act_IPBC",0.0);
247  auto hlt_el_mult = Monitored::Scalar<int>("hlt_el_mult",0.0);
248  auto hlt_el_pt = Monitored::Scalar<float>("hlt_el_pt",0.0);
249  auto hlt_mu_mult = Monitored::Scalar<int>("hlt_mu_mult",0.0);
250  auto hlt_mu_pt = Monitored::Scalar<float>("hlt_mu_pt",0.0);
251 
252  auto hlt_topoclusters_mult = Monitored::Scalar<int>("hlt_topoclusters_mult",0.0);
253  auto hlt_topoclusters_pt = Monitored::Scalar<float>("hlt_topoclusters_pt",0.0);
254  auto hlt_tracks_mult = Monitored::Scalar<int>("hlt_tracks_mult",0.0);
255  auto hlt_tracks_pt = Monitored::Scalar<float>("hlt_tracks_pt",0.0);
256  auto hlt_tracks_phi = Monitored::Scalar<float>("hlt_tracks_phi",0.0);
257  auto hlt_tracks_eta = Monitored::Scalar<float>("hlt_tracks_eta",0.0);
258  auto hlt_tracks_leading_pt = Monitored::Scalar<float>("hlt_tracks_leading_pt",0.0);
259  auto hlt_tracks_vec_sumPt = Monitored::Scalar<float>("hlt_tracks_vec_sumPt",0.0);
260  auto hlt_tracks_sca_sumPt = Monitored::Scalar<float>("hlt_tracks_sca_sumPt",0.0);
261  auto hlt_vertex_mult = Monitored::Scalar<int>("hlt_vertex_mult",0.0);
262  auto hlt_vertex_mult_mu = Monitored::Scalar<int>("hlt_vertex_mult_mu",0.0);
263  auto hlt_vertex_z = Monitored::Scalar<float>("hlt_vertex_z",0.0);
264  auto hlt_vertex_z_diff = Monitored::Scalar<float>("hlt_vertex_z_diff",0.0);
265 
266  auto offline_Ex = Monitored::Scalar<float>("offline_Ex",0.0);
267  auto offline_Ey = Monitored::Scalar<float>("offline_Ey",0.0);
268  auto offline_Et = Monitored::Scalar<float>("offline_Et",0.0);
269  auto offline_sumEt = Monitored::Scalar<float>("offline_sumEt",0.0);
270  auto offline_Et_eff = Monitored::Scalar<float>("offline_Et_eff",0.0);
271  auto offline_NoMu_Ex = Monitored::Scalar<float>("offline_NoMu_Ex",0.0);
272  auto offline_NoMu_Ey = Monitored::Scalar<float>("offline_NoMu_Ey",0.0);
273  auto offline_NoMu_Et = Monitored::Scalar<float>("offline_NoMu_Et",0.0);
274  auto offline_NoMu_sumEt = Monitored::Scalar<float>("offline_NoMu_sumEt",0.0);
275  auto offline_NoMu_Et_eff = Monitored::Scalar<float>("offline_NoMu_Et_eff",0.0);
276 
277  auto HLT_MET_status = Monitored::Scalar<int>("HLT_MET_status",0.0);
278  auto MET_status = Monitored::Scalar<float>("MET_status",0.0);
279  auto HLT_MET_component = Monitored::Scalar<int>("HLT_MET_component",0.0);
280  auto component_Et = Monitored::Scalar<float>("component_Et",0.0);
281  auto component = Monitored::Scalar<int>("component",0.0);
282  auto component_status = Monitored::Scalar<int>("component_status",0.0);
283  auto component_status_weight = Monitored::Scalar<int>("component_status_weight",0.0);
284 
285  // constant floor for log plots
286  double epsilon = 1.189;
287 
288  // for histogram filling
289  // Fill. First argument is the tool (GMT) name as defined in the py file,
290  // all others are the variables to be saved.
291  auto tool = getGroup("TrigMETMonitor");
292 
293  // access pileup <mu>
294  act_IPBC = eventInfo->actualInteractionsPerCrossing();
295 
296  // access lepton values
297  // access events with electron passing primary single electron chain
298  bool passedPrimaryEl = false;
299  for (const std::string& chain : m_hltChainEl){
300  if(getTrigDecisionTool()->isPassed(chain)){
301  passedPrimaryEl = true;
302  break;
303  }
304  }
305  if ( hlt_electron_cont.isValid() && passedPrimaryEl ){
306  hlt_el_mult = hlt_electron_cont->size();
307  fill(tool,hlt_el_mult);
308  if( hlt_electron_cont->size() > 0 ) {
309  for (auto Electron: *hlt_electron_cont) {
310  hlt_el_pt = Electron->pt()/Gaudi::Units::GeV;
311  fill(tool, hlt_el_pt);
312  }
313  }
314  }
315 
316  // access events with muon passing primary single muon chain
317  bool passedPrimaryMu = false;
318  for (const std::string& chain : m_hltChainMu){
319  if(getTrigDecisionTool()->isPassed(chain)){
320  passedPrimaryMu = true;
321  break;
322  }
323  }
324  if( hlt_muon_cont.isValid() &&passedPrimaryMu ){
325  hlt_mu_mult = hlt_muon_cont->size();
326  fill(tool,hlt_mu_mult);
327  if ( hlt_muon_cont->size() > 0 ){
328  for(auto Muon : *hlt_muon_cont){
329  hlt_mu_pt = Muon->pt()/Gaudi::Units::GeV;
330  fill(tool, hlt_mu_pt);
331  }
332  }
333  }
334 
335  // access topoclusters container
336  if(hlt_topoclusters_cont.isValid() && hlt_topoclusters_cont->size() > 0){
337  hlt_topoclusters_mult = hlt_topoclusters_cont->size();
338  for(auto topoclusters : *hlt_topoclusters_cont){
339  hlt_topoclusters_pt = topoclusters->pt()/Gaudi::Units::GeV;
340  if(hlt_topoclusters_pt > 0){
341  fill(tool, hlt_topoclusters_pt);
342  }
343  }
344 
345  if(hlt_topoclusters_mult > 0){
346  fill(tool, hlt_topoclusters_mult);
347  }
348  }
349 
350  // access tracks container
351  if( hlt_tracks_cont.isValid() && hlt_tracks_cont->size() > 0){
352  hlt_tracks_mult = hlt_tracks_cont->size();
353  float scalarSumPt = 0.0;
354  float scalarSumPx = 0.0;
355  float scalarSumPy = 0.0;
356  for(auto tracks : *hlt_tracks_cont){
357  float i_track_pt = tracks->pt()/Gaudi::Units::GeV;
358  hlt_tracks_pt = i_track_pt;
359  scalarSumPt += i_track_pt;
360  scalarSumPx += (tracks->p4().Px());
361  scalarSumPy += (tracks->p4().Py());
362 
363  if(hlt_tracks_pt > hlt_tracks_leading_pt){
364  hlt_tracks_leading_pt = i_track_pt;
365  }
366 
367  if(hlt_tracks_pt > 0){
368  fill(tool, hlt_tracks_pt);
369  }
370 
371  if(hlt_tracks_pt > 3){
372  hlt_tracks_eta = (tracks->eta());
373  hlt_tracks_phi = (tracks->phi());
374  fill(tool, hlt_tracks_eta, hlt_tracks_phi);
375  }
376  }
377 
378  hlt_tracks_vec_sumPt = std::sqrt(scalarSumPx*scalarSumPx + scalarSumPy*scalarSumPy)/Gaudi::Units::GeV;
379  hlt_tracks_sca_sumPt = scalarSumPt;
380 
381  fill(tool, hlt_tracks_mult, hlt_tracks_leading_pt, hlt_tracks_vec_sumPt, hlt_tracks_sca_sumPt);
382  }
383 
384  // access vertex container
385  if(hlt_vertex_cont.isValid() && hlt_vertex_cont->size() > 0){
386  hlt_vertex_mult = hlt_vertex_cont->size();
387  hlt_vertex_mult_mu = hlt_vertex_cont->size();
388  const xAOD::Vertex_v1* hlt_vertex = nullptr;
389  for(auto vertex : *hlt_vertex_cont){
390  if(vertex->vertexType() == xAOD::VxType::VertexType::PriVtx){
391  hlt_vertex = vertex;
392  break;
393  }
394  }
395 
396  if(hlt_vertex){
397  hlt_vertex_z = hlt_vertex->z();
398  fill(tool, hlt_vertex_z);
399 
400  if(offline_vertex_cont.isValid() && offline_vertex_cont->size() > 0){
401  const xAOD::Vertex_v1* offline_vertex = nullptr;
402  for(auto vertex : *offline_vertex_cont){
403  if(vertex->vertexType() == xAOD::VxType::VertexType::PriVtx){
404  offline_vertex = vertex;
405  break;
406  }
407  }
408 
409  if(offline_vertex){
410  hlt_vertex_z_diff = hlt_vertex_z - offline_vertex->z();
411  fill(tool, hlt_vertex_z_diff);
412  }
413  }
414  }
415  }else{
416  hlt_vertex_mult = -1;
417  hlt_vertex_mult_mu = 1;
418  act_IPBC = -1.;
419  }
420  fill(tool, hlt_vertex_mult);
421  fill(tool, act_IPBC, hlt_vertex_mult_mu);
422 
423  // access offline MET values
424  const xAOD::MissingET *finalTrkMET = 0;
425  const xAOD::MissingET *muonsMET = 0;
426  if ( offline_met_cont.isValid() && offline_met_cont->size() > 0 ) {
427  finalTrkMET = ((*offline_met_cont)["FinalTrk"]);
428  muonsMET = ((*offline_met_cont)["Muons"]);
429 
430  if(finalTrkMET) {
431  offline_Ex = - finalTrkMET->mpx()/Gaudi::Units::GeV;
432  offline_Ey = - finalTrkMET->mpy()/Gaudi::Units::GeV;
433  offline_sumEt = finalTrkMET->sumet()/Gaudi::Units::GeV;
434  offline_Et = std::sqrt(offline_Ex*offline_Ex + offline_Ey*offline_Ey);
435  offline_Et_eff = std::sqrt(offline_Ex*offline_Ex + offline_Ey*offline_Ey);
436  fill(tool,offline_Ex,offline_Ey,offline_Et,offline_sumEt);
437 
438  if(muonsMET){
439  xAOD::MissingET finalTrkNoMuMET = *finalTrkMET - *muonsMET;
440  offline_NoMu_Ex = - finalTrkNoMuMET.mpx()/Gaudi::Units::GeV;
441  offline_NoMu_Ey = - finalTrkNoMuMET.mpy()/Gaudi::Units::GeV;
442  offline_NoMu_sumEt = finalTrkNoMuMET.sumet()/Gaudi::Units::GeV;
443  offline_NoMu_Et = std::sqrt(offline_NoMu_Ex*offline_NoMu_Ex + offline_NoMu_Ey*offline_NoMu_Ey);
444  offline_NoMu_Et_eff = std::sqrt(offline_NoMu_Ex*offline_NoMu_Ex + offline_NoMu_Ey*offline_NoMu_Ey);
445  fill(tool,offline_NoMu_Ex,offline_NoMu_Ey,offline_NoMu_Et,offline_NoMu_sumEt);
446  }
447  }
448  }
449 
450  // access L1 MET values
451  for (const std::string& alg : m_algsL1) {
452  SG::ReadHandle<xAOD::EnergySumRoI> l1_met_cont;
453  if (alg == "roi" && l1_roi_cont.isValid()) {
454  l1_met_cont = l1_roi_cont;
455  }
456 
457  if ( l1_met_cont.isValid() ) {
458  if ((l1_met_cont->energyX())>-9e12 && (l1_met_cont->energyX())<9e12 && (l1_met_cont->energyY())>-9e12 && (l1_met_cont->energyY())<9e12) {
459  float L1_met_Ex = - l1_met_cont->energyX()/Gaudi::Units::GeV;
460  float L1_met_Ey = - l1_met_cont->energyY()/Gaudi::Units::GeV;
461  float L1_met_Et = std::sqrt(L1_met_Ex*L1_met_Ex + L1_met_Ey*L1_met_Ey);
462  float L1_met_sumEt = l1_met_cont->energyT()/Gaudi::Units::GeV;
463  float L1_met_Ex_log = signed_log(L1_met_Ex, epsilon);
464  float L1_met_Ey_log = signed_log(L1_met_Ey, epsilon);
465  float L1_met_Et_log = signed_log(L1_met_Et, epsilon);
466  float L1_met_sumEt_log = signed_log(L1_met_sumEt, epsilon);
467  TVector3 v(L1_met_Ex, L1_met_Ey, 0.0);
468  float L1_met_phi = v.Phi();
469 
470  auto L1_Ex = Monitored::Scalar<float>("L1_"+alg+"_Ex", static_cast<float>(L1_met_Ex));
471  auto L1_Ey = Monitored::Scalar<float>("L1_"+alg+"_Ey", static_cast<float>(L1_met_Ey));
472  auto L1_Et = Monitored::Scalar<float>("L1_"+alg+"_Et", static_cast<float>(L1_met_Et));
473  auto L1_sumEt = Monitored::Scalar<float>("L1_"+alg+"_sumEt", static_cast<float>(L1_met_sumEt));
474  auto L1_Ex_log = Monitored::Scalar<float>("L1_"+alg+"_Ex_log", static_cast<float>(L1_met_Ex_log));
475  auto L1_Ey_log = Monitored::Scalar<float>("L1_"+alg+"_Ey_log", static_cast<float>(L1_met_Ey_log));
476  auto L1_Et_log = Monitored::Scalar<float>("L1_"+alg+"_Et_log", static_cast<float>(L1_met_Et_log));
477  auto L1_sumEt_log = Monitored::Scalar<float>("L1_"+alg+"_sumEt_log", static_cast<float>(L1_met_sumEt_log));
478  auto L1_phi = Monitored::Scalar<float>("L1_"+alg+"_phi", static_cast<float>(L1_met_phi));
479  fill(tool, L1_Ex, L1_Ey, L1_Et, L1_sumEt,
480  L1_Ex_log, L1_Ey_log, L1_Et_log, L1_sumEt_log, L1_phi);
481  }
482  }
483  }
484 
485  // access L1 jFex MET values
486  if (l1_jFexMet_cont.isValid() && l1_jFexMet_cont->size() > 0) {
487  float L1_met_Ex = 0;
488  float L1_met_Ey = 0;
489  for (const auto l1_jmet: *l1_jFexMet_cont) {
490  L1_met_Ex += l1_jmet->Ex()/Gaudi::Units::GeV;
491  L1_met_Ey += l1_jmet->Ey()/Gaudi::Units::GeV;
492  }
493  float L1_met_Et = std::sqrt(L1_met_Ex*L1_met_Ex + L1_met_Ey*L1_met_Ey);
494  float L1_met_Ex_log = signed_log(L1_met_Ex, epsilon);
495  float L1_met_Ey_log = signed_log(L1_met_Ey, epsilon);
496  float L1_met_Et_log = signed_log(L1_met_Et, epsilon);
497  TVector3 v(L1_met_Ex, L1_met_Ey, 0.0);
498  float L1_met_phi = v.Phi();
499  auto L1_Ex = Monitored::Scalar<float>("L1_jFex_Ex", static_cast<float>(L1_met_Ex));
500  auto L1_Ey = Monitored::Scalar<float>("L1_jFex_Ey", static_cast<float>(L1_met_Ey));
501  auto L1_Et = Monitored::Scalar<float>("L1_jFex_Et", static_cast<float>(L1_met_Et));
502  auto L1_Ex_log = Monitored::Scalar<float>("L1_jFex_Ex_log", static_cast<float>(L1_met_Ex_log));
503  auto L1_Ey_log = Monitored::Scalar<float>("L1_jFex_Ey_log", static_cast<float>(L1_met_Ey_log));
504  auto L1_Et_log = Monitored::Scalar<float>("L1_jFex_Et_log", static_cast<float>(L1_met_Et_log));
505  auto L1_phi = Monitored::Scalar<float>("L1_jFex_phi", static_cast<float>(L1_met_phi));
506  fill(tool, L1_Ex, L1_Ey, L1_Et, L1_Ex_log, L1_Ey_log, L1_Et_log, L1_phi);
507  }
508  if (l1_jFexSumEt_cont.isValid() && l1_jFexSumEt_cont->size() > 0) {
509  float L1_met_sumEt = 0;
510  for (const auto l1_jsumEt: *l1_jFexSumEt_cont) {
511  L1_met_sumEt += l1_jsumEt->Et_lower()/Gaudi::Units::GeV + l1_jsumEt->Et_upper()/Gaudi::Units::GeV;
512  }
513  float L1_met_sumEt_log = signed_log(L1_met_sumEt, epsilon);
514  auto L1_sumEt = Monitored::Scalar<float>("L1_jFex_sumEt", static_cast<float>(L1_met_sumEt));
515  auto L1_sumEt_log = Monitored::Scalar<float>("L1_jFex_sumEt_log", static_cast<float>(L1_met_sumEt_log));
516  fill(tool, L1_sumEt, L1_sumEt_log);
517  }
518 
519  // define L1 gFex MET object
520  const xAOD::gFexGlobalRoI *l1_gmet;
521 
522  // access L1 gFex MET values
523  // This will be properly implemented when it's ready
524  if (l1_gFexJwojScalar_cont.isValid() && l1_gFexJwojScalar_cont->size() > 0) {
525  l1_gmet = l1_gFexJwojScalar_cont->at(0);
526  float L1_met_Et = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
527  float L1_met_sumEt = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
528  float L1_met_Et_log = signed_log(L1_met_Et, epsilon);
529  float L1_met_sumEt_log = signed_log(L1_met_sumEt, epsilon);
530  auto L1_Et = Monitored::Scalar<float>("L1_gFexJwoj_Et", static_cast<float>(L1_met_Et));
531  auto L1_Et_log = Monitored::Scalar<float>("L1_gFexJwoj_Et_log", static_cast<float>(L1_met_Et_log));
532  auto L1_sumEt = Monitored::Scalar<float>("L1_gFexJwoj_sumEt", static_cast<float>(L1_met_sumEt));
533  auto L1_sumEt_log = Monitored::Scalar<float>("L1_gFexJwoj_sumEt_log", static_cast<float>(L1_met_sumEt_log));
534  fill(tool, L1_Et, L1_Et_log, L1_sumEt, L1_sumEt_log);
535  }
536 
537  if (l1_gFexJwojMETComponents_cont.isValid() && l1_gFexJwojMETComponents_cont->size() > 0) {
538  l1_gmet = l1_gFexJwojMETComponents_cont->at(0);
539  float L1_met_Ex = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
540  float L1_met_Ex_log = signed_log(L1_met_Ex, epsilon);
541  float L1_met_Ey = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
542  float L1_met_Ey_log = signed_log(L1_met_Ey, epsilon);
543  TVector3 v(L1_met_Ex, L1_met_Ey, 0.0);
544  float L1_met_phi = v.Phi();
545  auto L1_Ex = Monitored::Scalar<float>("L1_gFexJwoj_Ex", static_cast<float>(L1_met_Ex));
546  auto L1_Ey = Monitored::Scalar<float>("L1_gFexJwoj_Ey", static_cast<float>(L1_met_Ey));
547  auto L1_Ex_log = Monitored::Scalar<float>("L1_gFexJwoj_Ex_log", static_cast<float>(L1_met_Ex_log));
548  auto L1_Ey_log = Monitored::Scalar<float>("L1_gFexJwoj_Ey_log", static_cast<float>(L1_met_Ey_log));
549  auto L1_phi = Monitored::Scalar<float>("L1_gFexJwoj_phi", static_cast<float>(L1_met_phi));
550  fill(tool, L1_Ex, L1_Ey, L1_Ex_log, L1_Ey_log, L1_phi);
551  }
552 
553  if (l1_gFexJwojMHTComponents_cont.isValid() && l1_gFexJwojMHTComponents_cont->size() > 0) {
554  l1_gmet = l1_gFexJwojMHTComponents_cont->at(0);
555  float L1_met_HT_Ex = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
556  float L1_met_HT_Ex_log = signed_log(L1_met_HT_Ex, epsilon);
557  float L1_met_HT_Ey = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
558  float L1_met_HT_Ey_log = signed_log(L1_met_HT_Ey, epsilon);
559  TVector3 v(L1_met_HT_Ex, L1_met_HT_Ey, 0.0);
560  float L1_met_HT_phi = v.Phi();
561  auto L1_HT_Ex = Monitored::Scalar<float>("L1_gFexJwoj_HT_Ex", static_cast<float>(L1_met_HT_Ex));
562  auto L1_HT_Ey = Monitored::Scalar<float>("L1_gFexJwoj_HT_Ey", static_cast<float>(L1_met_HT_Ey));
563  auto L1_HT_Ex_log = Monitored::Scalar<float>("L1_gFexJwoj_HT_Ex_log", static_cast<float>(L1_met_HT_Ex_log));
564  auto L1_HT_Ey_log = Monitored::Scalar<float>("L1_gFexJwoj_HT_Ey_log", static_cast<float>(L1_met_HT_Ey_log));
565  auto L1_HT_phi = Monitored::Scalar<float>("L1_gFexJwoj_HT_phi", static_cast<float>(L1_met_HT_phi));
566  fill(tool, L1_HT_Ex, L1_HT_Ey, L1_HT_Ex_log, L1_HT_Ey_log, L1_HT_phi);
567  }
568 
569  if (l1_gFexJwojMSTComponents_cont.isValid() && l1_gFexJwojMSTComponents_cont->size() > 0) {
570  l1_gmet = l1_gFexJwojMSTComponents_cont->at(0);
571  float L1_met_ST_Ex = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
572  float L1_met_ST_Ex_log = signed_log(L1_met_ST_Ex, epsilon);
573  float L1_met_ST_Ey = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
574  float L1_met_ST_Ey_log = signed_log(L1_met_ST_Ey, epsilon);
575  TVector3 v(L1_met_ST_Ex, L1_met_ST_Ey, 0.0);
576  float L1_met_ST_phi = v.Phi();
577  auto L1_ST_Ex = Monitored::Scalar<float>("L1_gFexJwoj_ST_Ex", static_cast<float>(L1_met_ST_Ex));
578  auto L1_ST_Ey = Monitored::Scalar<float>("L1_gFexJwoj_ST_Ey", static_cast<float>(L1_met_ST_Ey));
579  auto L1_ST_Ex_log = Monitored::Scalar<float>("L1_gFexJwoj_ST_Ex_log", static_cast<float>(L1_met_ST_Ex_log));
580  auto L1_ST_Ey_log = Monitored::Scalar<float>("L1_gFexJwoj_ST_Ey_log", static_cast<float>(L1_met_ST_Ey_log));
581  auto L1_ST_phi = Monitored::Scalar<float>("L1_gFexJwoj_ST_phi", static_cast<float>(L1_met_ST_phi));
582  fill(tool, L1_ST_Ex, L1_ST_Ey, L1_ST_Ex_log, L1_ST_Ey_log, L1_ST_phi);
583  }
584 
585  if (l1_gFexNCMETScalar_cont.isValid() && l1_gFexNCMETScalar_cont->size() > 0) {
586  l1_gmet = l1_gFexNCMETScalar_cont->at(0);
587  float L1_met_Et = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
588  float L1_met_sumEt = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
589  float L1_met_Et_log = signed_log(L1_met_Et, epsilon);
590  float L1_met_sumEt_log = signed_log(L1_met_sumEt, epsilon);
591  auto L1_Et = Monitored::Scalar<float>("L1_gFexNC_Et", static_cast<float>(L1_met_Et));
592  auto L1_Et_log = Monitored::Scalar<float>("L1_gFexNC_Et_log", static_cast<float>(L1_met_Et_log));
593  auto L1_sumEt = Monitored::Scalar<float>("L1_gFexNC_sumEt", static_cast<float>(L1_met_sumEt));
594  auto L1_sumEt_log = Monitored::Scalar<float>("L1_gFexNC_sumEt_log", static_cast<float>(L1_met_sumEt_log));
595  fill(tool, L1_Et, L1_Et_log, L1_sumEt, L1_sumEt_log);
596  }
597 
598  if (l1_gFexNCMETComponents_cont.isValid() && l1_gFexNCMETComponents_cont->size() > 0) {
599  l1_gmet = l1_gFexNCMETComponents_cont->at(0);
600  float L1_met_Ex = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
601  float L1_met_Ex_log = signed_log(L1_met_Ex, epsilon);
602  float L1_met_Ey = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
603  float L1_met_Ey_log = signed_log(L1_met_Ey, epsilon);
604  TVector3 v(L1_met_Ex, L1_met_Ey, 0.0);
605  float L1_met_phi = v.Phi();
606  auto L1_Ex = Monitored::Scalar<float>("L1_gFexNC_Ex", static_cast<float>(L1_met_Ex));
607  auto L1_Ey = Monitored::Scalar<float>("L1_gFexNC_Ey", static_cast<float>(L1_met_Ey));
608  auto L1_Ex_log = Monitored::Scalar<float>("L1_gFexNC_Ex_log", static_cast<float>(L1_met_Ex_log));
609  auto L1_Ey_log = Monitored::Scalar<float>("L1_gFexNC_Ey_log", static_cast<float>(L1_met_Ey_log));
610  auto L1_phi = Monitored::Scalar<float>("L1_gFexNC_phi", static_cast<float>(L1_met_phi));
611  fill(tool, L1_Ex, L1_Ey, L1_Ex_log, L1_Ey_log, L1_phi);
612  }
613 
614  if (l1_gFexRhoMETScalar_cont.isValid() && l1_gFexRhoMETScalar_cont->size() > 0) {
615  l1_gmet = l1_gFexRhoMETScalar_cont->at(0);
616  float L1_met_Et = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
617  float L1_met_sumEt = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
618  float L1_met_Et_log = signed_log(L1_met_Et, epsilon);
619  float L1_met_sumEt_log = signed_log(L1_met_sumEt, epsilon);
620  auto L1_Et = Monitored::Scalar<float>("L1_gFexRho_Et", static_cast<float>(L1_met_Et));
621  auto L1_Et_log = Monitored::Scalar<float>("L1_gFexRho_Et_log", static_cast<float>(L1_met_Et_log));
622  auto L1_sumEt = Monitored::Scalar<float>("L1_gFexRho_sumEt", static_cast<float>(L1_met_sumEt));
623  auto L1_sumEt_log = Monitored::Scalar<float>("L1_gFexRho_sumEt_log", static_cast<float>(L1_met_sumEt_log));
624  fill(tool, L1_Et, L1_Et_log, L1_sumEt, L1_sumEt_log);
625  }
626 
627  if (l1_gFexRhoMETComponents_cont.isValid() && l1_gFexRhoMETComponents_cont->size() > 0) {
628  l1_gmet = l1_gFexRhoMETComponents_cont->at(0);
629  float L1_met_Ex = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
630  float L1_met_Ex_log = signed_log(L1_met_Ex, epsilon);
631  float L1_met_Ey = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
632  float L1_met_Ey_log = signed_log(L1_met_Ey, epsilon);
633  TVector3 v(L1_met_Ex, L1_met_Ey, 0.0);
634  float L1_met_phi = v.Phi();
635  auto L1_Ex = Monitored::Scalar<float>("L1_gFexRho_Ex", static_cast<float>(L1_met_Ex));
636  auto L1_Ey = Monitored::Scalar<float>("L1_gFexRho_Ey", static_cast<float>(L1_met_Ey));
637  auto L1_Ex_log = Monitored::Scalar<float>("L1_gFexRho_Ex_log", static_cast<float>(L1_met_Ex_log));
638  auto L1_Ey_log = Monitored::Scalar<float>("L1_gFexRho_Ey_log", static_cast<float>(L1_met_Ey_log));
639  auto L1_phi = Monitored::Scalar<float>("L1_gFexRho_phi", static_cast<float>(L1_met_phi));
640  fill(tool, L1_Ex, L1_Ey, L1_Ex_log, L1_Ey_log, L1_phi);
641  }
642 
643  // define TrigMissingET object
644  const xAOD::TrigMissingET *hlt_met = 0;
645 
646  // status, component from HLT cell
647  int nComponent = m_compNames.size();
648  int nStatus = m_bitNames.size();
649  if ( hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0 ) {
650  hlt_met = hlt_cell_met_cont->at(0);
651  for (int j=0; j<nStatus; ++j) { //status loop
652  unsigned mask = (1u<<j);
653  if (hlt_met->flag() & mask) {
654  MET_status = 1.;
655  } else {
656  MET_status = 0;
657  }
658  auto mon1 = Monitored::Scalar<std::string>( "HLT_MET_status",m_bitNames[j]);
659  fill(tool,mon1,MET_status);
660  }
661 
662  for (int i=0; i<nComponent; ++i) { //component loop
663  float ex = hlt_met->exComponent(i)/Gaudi::Units::GeV;
664  float ey = hlt_met->eyComponent(i)/Gaudi::Units::GeV;
665  component_Et = sqrt(ex*ex+ey*ey);
666  auto mon2 = Monitored::Scalar<std::string>( "HLT_MET_component",m_compNames[i]);
667  fill(tool,mon2,component_Et);
668  }
669 
670  for (int i=0; i<nComponent; ++i) { //component loop
671  for (int j=0; j<nStatus; ++j) { //status loop
672  unsigned mask = (1u<<j);
673  if (hlt_met->statusComponent(i) & mask) {
674  component_status_weight = 1.;
675  } else {
676  component_status_weight = 0;
677  }
678  auto mon_bit = Monitored::Scalar<std::string>( "component_status",m_bitNames[j]);
679  auto mon_comp = Monitored::Scalar<std::string>( "component",m_compNames[i]);
680  fill(tool,mon_comp,mon_bit,component_status_weight);
681  }
682  }
683  }
684 
685  // get L1 MET for pre-selection
686  float L1_roiMet_Et = 0;
687  if ( l1_roi_cont.isValid() ) {
688  if ((l1_roi_cont->energyX())>-9e12 && (l1_roi_cont->energyX())<9e12 && (l1_roi_cont->energyY())>-9e12 && (l1_roi_cont->energyY())<9e12) {
689  float Ex = - l1_roi_cont->energyX()/Gaudi::Units::GeV;
690  float Ey = - l1_roi_cont->energyY()/Gaudi::Units::GeV;
691  L1_roiMet_Et = std::sqrt(Ex*Ex + Ey*Ey);
692  }
693  }
694  float L1_jFexMet_Et = 0;
695  if (l1_jFexMet_cont.isValid() && l1_jFexMet_cont->size() > 0) {
696  float L1_met_Ex = 0;
697  float L1_met_Ey = 0;
698  for (const auto l1_jmet: *l1_jFexMet_cont) {
699  L1_met_Ex += l1_jmet->Ex()/Gaudi::Units::GeV;
700  L1_met_Ey += l1_jmet->Ey()/Gaudi::Units::GeV;
701  }
702  L1_jFexMet_Et = std::sqrt(L1_met_Ex*L1_met_Ex + L1_met_Ey*L1_met_Ey);
703  }
704  float L1_gFexJWOJMet_Et = 0;
705 
706  float L1_PreSelMet_Et = L1_roiMet_Et;
707  if (m_L1MetAlg == 1) L1_PreSelMet_Et = L1_jFexMet_Et;
708  if (m_L1MetAlg == 2) L1_PreSelMet_Et = L1_gFexJWOJMet_Et;
709 
710  // access HLT MET values
711  for (const std::string& alg : m_algsHLT) {
712  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
713  hlt_met = hlt_cell_met_cont->at(0);
714  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
715  hlt_met = hlt_mht_met_cont->at(0);
716  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
717  hlt_met = hlt_tc_met_cont->at(0);
718  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
719  hlt_met = hlt_tc_em_met_cont->at(0);
720  } else if (alg == "tcpufit" && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0) {
721  hlt_met = hlt_tcpufit_met_cont->at(0);
722  } else if (alg == "tcpufit_sig30" && hlt_tcpufit_sig30_met_cont.isValid() && hlt_tcpufit_sig30_met_cont->size() > 0) {
723  hlt_met = hlt_tcpufit_sig30_met_cont->at(0);
724  } else if (alg == "trkmht" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
725  hlt_met = hlt_trkmht_met_cont->at(0);
726  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
727  hlt_met = hlt_pfsum_met_cont->at(0);
728  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
729  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
730  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
731  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
732  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
733  hlt_met = hlt_pfopufit_met_cont->at(0);
734  } else if (alg == "pfopufit_sig30" && hlt_pfopufit_sig30_met_cont.isValid() && hlt_pfopufit_sig30_met_cont->size() > 0) {
735  hlt_met = hlt_pfopufit_sig30_met_cont->at(0);
736  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
737  hlt_met = hlt_cvfpufit_met_cont->at(0);
738  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
739  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
740  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
741  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
742  } else if (alg == "met_nn" && hlt_met_nn_cont.isValid() && hlt_met_nn_cont->size() > 0) {
743  hlt_met = hlt_met_nn_cont->at(0);
744  } else {
745  hlt_met = 0;
746  }
747 
748  if ( hlt_met ) {
749  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
750  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
751  float hlt_Ez = hlt_met->ez()/Gaudi::Units::GeV;
752  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
753  float hlt_sumEt = hlt_met->sumEt()/Gaudi::Units::GeV;
754  float hlt_Ex_log = signed_log(hlt_Ex, epsilon);
755  float hlt_Ey_log = signed_log(hlt_Ey, epsilon);
756  float hlt_Et_log = signed_log(hlt_Et, epsilon);
757  float hlt_sumEt_log = signed_log(hlt_sumEt, epsilon);
758  TVector3 v(hlt_Ex, hlt_Ey, hlt_Ez);
759  float hlt_eta = v.Eta();
760  float hlt_phi = v.Phi();
761 
762  auto met_Ex = Monitored::Scalar<float>(alg+"_Ex", static_cast<float>(hlt_Ex));
763  auto met_Ey = Monitored::Scalar<float>(alg+"_Ey", static_cast<float>(hlt_Ey));
764  auto met_Et = Monitored::Scalar<float>(alg+"_Et", static_cast<float>(hlt_Et));
765  auto met_sumEt = Monitored::Scalar<float>(alg+"_sumEt", static_cast<float>(hlt_sumEt));
766  auto met_Ex_log = Monitored::Scalar<float>(alg+"_Ex_log", static_cast<float>(hlt_Ex_log));
767  auto met_Ey_log = Monitored::Scalar<float>(alg+"_Ey_log", static_cast<float>(hlt_Ey_log));
768  auto met_Et_log = Monitored::Scalar<float>(alg+"_Et_log", static_cast<float>(hlt_Et_log));
769  auto met_sumEt_log = Monitored::Scalar<float>(alg+"_sumEt_log", static_cast<float>(hlt_sumEt_log));
770  auto met_eta = Monitored::Scalar<float>(alg+"_eta", static_cast<float>(hlt_eta));
771  auto met_phi = Monitored::Scalar<float>(alg+"_phi", static_cast<float>(hlt_phi));
772  fill(tool,met_Ex,met_Ey,met_Et,met_sumEt,
773  met_Ex_log,met_Ey_log,met_Et_log,met_sumEt_log,
774  met_eta,met_phi);
775 
776  }
777  }
778 
779  // access HLT pre-selection MET values
780  for (const std::string& alg : m_algsHLTPreSel) {
781  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
782  hlt_met = hlt_cell_met_cont->at(0);
783  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
784  hlt_met = hlt_mht_met_cont->at(0);
785  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
786  hlt_met = hlt_tc_met_cont->at(0);
787  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
788  hlt_met = hlt_tc_em_met_cont->at(0);
789  } else if (alg == "tcpufit" && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0) {
790  hlt_met = hlt_tcpufit_met_cont->at(0);
791  } else if (alg == "tcpufit_sig30" && hlt_tcpufit_sig30_met_cont.isValid() && hlt_tcpufit_sig30_met_cont->size() > 0) {
792  hlt_met = hlt_tcpufit_sig30_met_cont->at(0);
793  } else if (alg == "trkmht" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
794  hlt_met = hlt_trkmht_met_cont->at(0);
795  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
796  hlt_met = hlt_pfsum_met_cont->at(0);
797  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
798  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
799  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
800  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
801  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
802  hlt_met = hlt_pfopufit_met_cont->at(0);
803  } else if (alg == "pfopufit_sig30" && hlt_pfopufit_sig30_met_cont.isValid() && hlt_pfopufit_sig30_met_cont->size() > 0) {
804  hlt_met = hlt_pfopufit_sig30_met_cont->at(0);
805  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
806  hlt_met = hlt_cvfpufit_met_cont->at(0);
807  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
808  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
809  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
810  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
811  } else if (alg == "met_nn" && hlt_met_nn_cont.isValid() && hlt_met_nn_cont->size() > 0) {
812  hlt_met = hlt_met_nn_cont->at(0);
813  } else {
814  hlt_met = 0;
815  }
816 
817  if ( hlt_met ) {
818  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
819  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
820  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
821  if (L1_PreSelMet_Et > m_L1MetCut && !std::isnan(hlt_Et)) {
822  auto met_presel_Et = Monitored::Scalar<float>(alg+"_presel_Et", hlt_Et);
823  fill(tool,met_presel_Et);
824  }
825  }
826  }
827 
828  for (const std::string& alg : m_LArNoiseBurstVetoAlgs) {
829  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
830  hlt_met = hlt_cell_met_cont->at(0);
831  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
832  hlt_met = hlt_mht_met_cont->at(0);
833  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
834  hlt_met = hlt_tc_met_cont->at(0);
835  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
836  hlt_met = hlt_tc_em_met_cont->at(0);
837  } else if (alg == "tcpufit" && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0) {
838  hlt_met = hlt_tcpufit_met_cont->at(0);
839  } else if (alg == "trkmht" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
840  hlt_met = hlt_trkmht_met_cont->at(0);
841  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
842  hlt_met = hlt_pfsum_met_cont->at(0);
843  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
844  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
845  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
846  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
847  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
848  hlt_met = hlt_pfopufit_met_cont->at(0);
849  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
850  hlt_met = hlt_cvfpufit_met_cont->at(0);
851  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
852  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
853  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
854  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
855  } else {
856  hlt_met = 0;
857  }
858 
859  if ( hlt_met ) {
860  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
861  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
862  float hlt_Ez = hlt_met->ez()/Gaudi::Units::GeV;
863  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
864  float hlt_sumEt = hlt_met->sumEt()/Gaudi::Units::GeV;
865  float hlt_Ex_log = signed_log(hlt_Ex, epsilon);
866  float hlt_Ey_log = signed_log(hlt_Ey, epsilon);
867  float hlt_Et_log = signed_log(hlt_Et, epsilon);
868  float hlt_sumEt_log = signed_log(hlt_sumEt, epsilon);
869  TVector3 v(hlt_Ex, hlt_Ey, hlt_Ez);
870  float hlt_eta = v.Eta();
871  float hlt_phi = v.Phi();
872 
873 
874  // LAr noiseburst Veto
875  bool LArNoiseBurst = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO);
876  if (!LArNoiseBurst){
877  auto met_Ex = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Ex", static_cast<float>(hlt_Ex));
878  auto met_Ey = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Ey", static_cast<float>(hlt_Ey));
879  auto met_Et = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Et", static_cast<float>(hlt_Et));
880  auto met_sumEt = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_sumEt", static_cast<float>(hlt_sumEt));
881  auto met_Ex_log = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Ex_log", static_cast<float>(hlt_Ex_log));
882  auto met_Ey_log = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Ey_log", static_cast<float>(hlt_Ey_log));
883  auto met_Et_log = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Et_log", static_cast<float>(hlt_Et_log));
884  auto met_sumEt_log = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_sumEt_log", static_cast<float>(hlt_sumEt_log));
885  auto met_phi = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_phi", static_cast<float>(hlt_phi));
886  auto met_eta = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_eta", static_cast<float>(hlt_eta));
887  fill(tool,met_Ex,met_Ey,met_Et,met_sumEt,
888  met_Ex_log,met_Ey_log,met_Et_log,met_sumEt_log,
889  met_eta,met_phi);
890  }
891  }
892  }
893 
894 
895  for (const std::string& alg : m_signalLepAlgs) {
896  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
897  hlt_met = hlt_cell_met_cont->at(0);
898  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
899  hlt_met = hlt_mht_met_cont->at(0);
900  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
901  hlt_met = hlt_tc_met_cont->at(0);
902  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
903  hlt_met = hlt_tc_em_met_cont->at(0);
904  } else if (alg == "tcpufit" && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0) {
905  hlt_met = hlt_tcpufit_met_cont->at(0);
906  } else if (alg == "trkmht" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
907  hlt_met = hlt_trkmht_met_cont->at(0);
908  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
909  hlt_met = hlt_pfsum_met_cont->at(0);
910  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
911  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
912  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
913  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
914  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
915  hlt_met = hlt_pfopufit_met_cont->at(0);
916  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
917  hlt_met = hlt_cvfpufit_met_cont->at(0);
918  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
919  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
920  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
921  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
922  } else {
923  hlt_met = 0;
924  }
925 
926  if ( hlt_met ) {
927  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
928  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
929  float hlt_Ez = hlt_met->ez()/Gaudi::Units::GeV;
930  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
931  float hlt_sumEt = hlt_met->sumEt()/Gaudi::Units::GeV;
932  float hlt_Ex_log = signed_log(hlt_Ex, epsilon);
933  float hlt_Ey_log = signed_log(hlt_Ey, epsilon);
934  float hlt_Et_log = signed_log(hlt_Et, epsilon);
935  float hlt_sumEt_log = signed_log(hlt_sumEt, epsilon);
936  TVector3 v(hlt_Ex, hlt_Ey, hlt_Ez);
937  float hlt_eta = v.Eta();
938  float hlt_phi = v.Phi();
939 
940 // access events with electron passing primary single electron chain
941  if(passedPrimaryEl){
942  auto met_Ex = Monitored::Scalar<float>(alg+"_SigEl_Ex", static_cast<float>(hlt_Ex));
943  auto met_Ey = Monitored::Scalar<float>(alg+"_SigEl_Ey", static_cast<float>(hlt_Ey));
944  auto met_Et = Monitored::Scalar<float>(alg+"_SigEl_Et", static_cast<float>(hlt_Et));
945  auto met_sumEt = Monitored::Scalar<float>(alg+"_SigEl_sumEt", static_cast<float>(hlt_sumEt));
946  auto met_Ex_log = Monitored::Scalar<float>(alg+"_SigEl_Ex_log", static_cast<float>(hlt_Ex_log));
947  auto met_Ey_log = Monitored::Scalar<float>(alg+"_SigEl_Ey_log", static_cast<float>(hlt_Ey_log));
948  auto met_Et_log = Monitored::Scalar<float>(alg+"_SigEl_Et_log", static_cast<float>(hlt_Et_log));
949  auto met_sumEt_log = Monitored::Scalar<float>(alg+"_SigEl_sumEt_log", static_cast<float>(hlt_sumEt_log));
950  auto met_eta = Monitored::Scalar<float>(alg+"_SigEl_eta", static_cast<float>(hlt_eta));
951  auto met_phi = Monitored::Scalar<float>(alg+"_SigEl_phi", static_cast<float>(hlt_phi));
952  fill(tool,met_Ex,met_Ey,met_Et,met_sumEt,
953  met_Ex_log,met_Ey_log,met_Et_log,met_sumEt_log,
954  met_eta,met_phi);
955  }
956 
957 // access events with muon passing primary single muon chain
958  if(passedPrimaryMu){
959  auto met_Ex = Monitored::Scalar<float>(alg+"_SigMu_Ex", static_cast<float>(hlt_Ex));
960  auto met_Ey = Monitored::Scalar<float>(alg+"_SigMu_Ey", static_cast<float>(hlt_Ey));
961  auto met_Et = Monitored::Scalar<float>(alg+"_SigMu_Et", static_cast<float>(hlt_Et));
962  auto met_sumEt = Monitored::Scalar<float>(alg+"_SigMu_sumEt", static_cast<float>(hlt_sumEt));
963  auto met_Ex_log = Monitored::Scalar<float>(alg+"_SigMu_Ex_log", static_cast<float>(hlt_Ex_log));
964  auto met_Ey_log = Monitored::Scalar<float>(alg+"_SigMu_Ey_log", static_cast<float>(hlt_Ey_log));
965  auto met_Et_log = Monitored::Scalar<float>(alg+"_SigMu_Et_log", static_cast<float>(hlt_Et_log));
966  auto met_sumEt_log = Monitored::Scalar<float>(alg+"_SigMu_sumEt_log", static_cast<float>(hlt_sumEt_log));
967  auto met_eta = Monitored::Scalar<float>(alg+"_SigMu_eta", static_cast<float>(hlt_eta));
968  auto met_phi = Monitored::Scalar<float>(alg+"_SigMu_phi", static_cast<float>(hlt_phi));
969  fill(tool,met_Ex,met_Ey,met_Et,met_sumEt,
970  met_Ex_log,met_Ey_log,met_Et_log,met_sumEt_log,
971  met_eta,met_phi);
972  }
973  }
974  }
975 
976  // access HLT MET Expert values
977  for (const std::string& alg : m_algsHLTExpert) {
978  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
979  hlt_met = hlt_cell_met_cont->at(0);
980  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
981  hlt_met = hlt_mht_met_cont->at(0);
982  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
983  hlt_met = hlt_tc_met_cont->at(0);
984  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
985  hlt_met = hlt_tc_em_met_cont->at(0);
986  } else if (alg == "tcpufit" && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0) {
987  hlt_met = hlt_tcpufit_met_cont->at(0);
988  } else if (alg == "tcpufit_sig30" && hlt_tcpufit_sig30_met_cont.isValid() && hlt_tcpufit_sig30_met_cont->size() > 0) {
989  hlt_met = hlt_tcpufit_sig30_met_cont->at(0);
990  } else if (alg == "trkmht" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
991  hlt_met = hlt_trkmht_met_cont->at(0);
992  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
993  hlt_met = hlt_pfsum_met_cont->at(0);
994  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
995  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
996  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
997  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
998  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
999  hlt_met = hlt_pfopufit_met_cont->at(0);
1000  } else if (alg == "pfopufit_sig30" && hlt_pfopufit_sig30_met_cont.isValid() && hlt_pfopufit_sig30_met_cont->size() > 0) {
1001  hlt_met = hlt_pfopufit_sig30_met_cont->at(0);
1002  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
1003  hlt_met = hlt_cvfpufit_met_cont->at(0);
1004  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
1005  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
1006  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
1007  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
1008  } else if (alg == "met_nn" && hlt_met_nn_cont.isValid() && hlt_met_nn_cont->size() > 0) {
1009  hlt_met = hlt_met_nn_cont->at(0);
1010  } else {
1011  hlt_met = 0;
1012  }
1013 
1014  if ( hlt_met ) {
1015  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
1016  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
1017  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
1018  float hlt_sumEt = hlt_met->sumEt()/Gaudi::Units::GeV;
1019  if (!std::isnan(hlt_Et)) {
1020  auto met_Ex = Monitored::Scalar<float>(alg+"_Ex", static_cast<float>(hlt_Ex));
1021  auto met_Ey = Monitored::Scalar<float>(alg+"_Ey", static_cast<float>(hlt_Ey));
1022  auto met_Et = Monitored::Scalar<float>(alg+"_Et", static_cast<float>(hlt_Et));
1023  auto met_sumEt = Monitored::Scalar<float>(alg+"_sumEt", static_cast<float>(hlt_sumEt));
1024  fill(tool,met_Ex,met_Ey,met_Et,met_sumEt);
1025  ATH_MSG_DEBUG(alg << ": hlt_Et = " << hlt_Et);
1026  if (L1_roiMet_Et > 50.) {
1027  auto met_presel_Et = Monitored::Scalar<float>(alg+"_presel_Et", static_cast<float>(hlt_Et));
1028  fill(tool,met_presel_Et);
1029  }
1030  }
1031  }
1032  }
1033 
1034  // Make 2D tcpufit MET distributions wrt track-based MET
1035  const xAOD::TrigMissingET *hlt_tcpufit_met = 0;
1036  for (const std::string& alg : m_algsMET2d_tcpufit) {
1037  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
1038  hlt_met = hlt_cell_met_cont->at(0);
1039  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
1040  hlt_met = hlt_mht_met_cont->at(0);
1041  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
1042  hlt_met = hlt_tc_met_cont->at(0);
1043  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
1044  hlt_met = hlt_tc_em_met_cont->at(0);
1045  } else if (alg == "trkmht_pf" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
1046  hlt_met = hlt_trkmht_met_cont->at(0);
1047  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
1048  hlt_met = hlt_pfsum_met_cont->at(0);
1049  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
1050  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
1051  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
1052  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
1053  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
1054  hlt_met = hlt_pfopufit_met_cont->at(0);
1055  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
1056  hlt_met = hlt_cvfpufit_met_cont->at(0);
1057  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
1058  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
1059  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
1060  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
1061  } else {
1062  hlt_met = 0;
1063  }
1064 
1065  if(hlt_met && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0){
1066  hlt_tcpufit_met = hlt_tcpufit_met_cont->at(0);
1067  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
1068  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
1069  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
1070  auto met_Et = Monitored::Scalar<float>(alg+"_2D_Et", static_cast<float>(hlt_Et));
1071 
1072  float hlt_tcpufit_Ex = hlt_tcpufit_met->ex()/Gaudi::Units::GeV;
1073  float hlt_tcpufit_Ey = hlt_tcpufit_met->ey()/Gaudi::Units::GeV;
1074  float hlt_tcpufit_Et = std::sqrt(hlt_tcpufit_Ex*hlt_tcpufit_Ex + hlt_tcpufit_Ey*hlt_tcpufit_Ey);
1075  auto tcpufit_met_Et = Monitored::Scalar<float>("tcpufit_2D_Et", static_cast<float>(hlt_tcpufit_Et));
1076  fill(tool, met_Et, tcpufit_met_Et);
1077  }
1078  }
1079 
1080  // efficiency plots
1081  for (const std::string& chain : m_l1Chains) {
1082  auto pass_chain = Monitored::Scalar<float>("pass_" + chain, static_cast<float>(getTrigDecisionTool()->isPassed(chain)));
1083  fill(tool, pass_chain,offline_NoMu_Et_eff);
1084  }
1085  for (const std::string& chain : m_hltChains) {
1086  auto pass_chain = Monitored::Scalar<float>("pass_" + chain, static_cast<float>(getTrigDecisionTool()->isPassed(chain)));
1087  fill(tool, pass_chain,offline_NoMu_Et_eff);
1088  }
1089  for (const std::string& chain : m_hltChainsVal) {
1090  auto pass_chain = Monitored::Scalar<float>("pass_" + chain, static_cast<float>(getTrigDecisionTool()->isPassed(chain)));
1091  fill(tool, pass_chain,offline_NoMu_Et_eff);
1092  }
1093  for (const std::string& chain : m_hltChainsT0) {
1094  auto pass_chain = Monitored::Scalar<float>("pass_" + chain, static_cast<float>(getTrigDecisionTool()->isPassed(chain)));
1095  fill(tool, pass_chain,offline_NoMu_Et_eff);
1096  }
1097 
1098  return StatusCode::SUCCESS;
1099 }
1100 
1101 
1102 double TrigMETMonitorAlgorithm::signed_log(double e, double epsilon) const {
1103 
1104 
1105  double e_log = -9e9;
1106  if (std::abs(e) > epsilon)
1107  e_log = std::copysign(std::log10(std::abs(e)), e);
1108  else
1109  e_log = 0.01;
1110 
1111  return e_log;
1112 }
TrigMETMonitorAlgorithm::m_hlt_pfopufit_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_pfopufit_met_key
Definition: TrigMETMonitorAlgorithm.h:80
TrigMETMonitorAlgorithm::signed_log
double signed_log(double e, double epsilon) const
Definition: TrigMETMonitorAlgorithm.cxx:1102
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xAOD::TrigMissingET_v1::sumEt
float sumEt() const
Get the sum of the ET of the missing energy.
xAOD::TrigMissingET_v1::exComponent
float exComponent(unsigned int index) const
Get the x component fo the energy of a component.
Definition: TrigMissingET_v1.cxx:119
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
TrigMETMonitorAlgorithm::m_hlt_met_nn_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_met_nn_key
Definition: TrigMETMonitorAlgorithm.h:85
TrigMETMonitorAlgorithm::m_hlt_trkmht_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_trkmht_met_key
Definition: TrigMETMonitorAlgorithm.h:76
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
TrigMETMonitorAlgorithm::m_algsMET2d_tcpufit
Gaudi::Property< std::vector< std::string > > m_algsMET2d_tcpufit
Definition: TrigMETMonitorAlgorithm.h:99
TrigMETMonitorAlgorithm::m_hltChainsT0
Gaudi::Property< std::vector< std::string > > m_hltChainsT0
Definition: TrigMETMonitorAlgorithm.h:90
TrigMETMonitorAlgorithm::TrigMETMonitorAlgorithm
TrigMETMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TrigMETMonitorAlgorithm.cxx:10
xAOD::TrigMissingET_v1::statusComponent
short statusComponent(unsigned int index) const
Get Status.
Definition: TrigMissingET_v1.cxx:207
xAOD::MissingET_v1::sumet
float sumet() const
Returns.
TrigMETMonitorAlgorithm::m_signalLepAlgs
Gaudi::Property< std::vector< std::string > > m_signalLepAlgs
Definition: TrigMETMonitorAlgorithm.h:110
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
TrigMETMonitorAlgorithm::m_hlt_cell_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_cell_met_key
Definition: TrigMETMonitorAlgorithm.h:70
xAOD::EnergySumRoI_v2::energyT
float energyT() const
The deposited total transverse energy.
CaloClusterMLCalib::epsilon
constexpr float epsilon
Definition: CaloClusterMLGaussianMixture.h:16
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
AthMonitorAlgorithm::getTrigDecisionTool
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool() const
Get the trigger decision tool member.
Definition: AthMonitorAlgorithm.cxx:194
xAOD::gFexGlobalRoI_v1
Class describing properties of a LVL1 gFEX global Trigger Object (TOB) in the xAOD format.
Definition: gFexGlobalRoI_v1.h:25
TrigMETMonitorAlgorithm::m_l1_gFexJwojScalar_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexJwojScalar_key
Definition: TrigMETMonitorAlgorithm.h:61
xAOD::TrigMissingET_v1::ex
float ex() const
Get the x component of the missing energy.
TrigMETMonitorAlgorithm::m_hlt_cvfpufit_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_cvfpufit_met_key
Definition: TrigMETMonitorAlgorithm.h:82
xAOD::TrigMissingET_v1::flag
int flag() const
Get the status flag.
xAOD::gFexGlobalRoI_v1::METquantityOne
float METquantityOne() const
retrieves the Et index from the 32-bit word
TrigDecisionTool.h
xAOD::EnergySumRoI_v2::energyY
float energyY() const
The total energy deposited in the Y direction.
TrigMETMonitorAlgorithm::m_LArNoiseBurstVetoAlgs
Gaudi::Property< std::vector< std::string > > m_LArNoiseBurstVetoAlgs
Definition: TrigMETMonitorAlgorithm.h:96
TrigMETMonitorAlgorithm::m_hltChainEl
Gaudi::Property< std::vector< std::string > > m_hltChainEl
Definition: TrigMETMonitorAlgorithm.h:91
TrigMETMonitorAlgorithm::m_hlt_pfopufit_sig30_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_pfopufit_sig30_met_key
Definition: TrigMETMonitorAlgorithm.h:81
TrigMETMonitorAlgorithm::m_hlt_pfsum_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_pfsum_met_key
Definition: TrigMETMonitorAlgorithm.h:77
Muon
NRpcCablingAlg reads raw condition data and writes derived condition data to the condition store.
Definition: TrackSystemController.h:45
TrigMETMonitorAlgorithm::m_l1Chains
Gaudi::Property< std::vector< std::string > > m_l1Chains
Definition: TrigMETMonitorAlgorithm.h:87
TrigMETMonitorAlgorithm::m_hlt_tcpufit_sig30_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_tcpufit_sig30_met_key
Definition: TrigMETMonitorAlgorithm.h:75
xAOD::EventInfo_v1::LAr
@ LAr
The LAr calorimeter.
Definition: EventInfo_v1.h:335
TrigMETMonitorAlgorithm::m_l1_gFexJwojMSTComponents_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexJwojMSTComponents_key
Definition: TrigMETMonitorAlgorithm.h:64
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:459
LArEventBitInfo.h
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
TrigMETMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: TrigMETMonitorAlgorithm.cxx:60
xAOD::gFexGlobalRoI_v1::METquantityTwo
float METquantityTwo() const
floating point value (GeV, TOB scale)
TrigMETMonitorAlgorithm::m_bitNames
Gaudi::Property< std::vector< std::string > > m_bitNames
Definition: TrigMETMonitorAlgorithm.h:101
TrigMETMonitorAlgorithm::m_l1_gFexNCMETComponents_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexNCMETComponents_key
Definition: TrigMETMonitorAlgorithm.h:66
LArEventBitInfo::NOISEBURSTVETO
@ NOISEBURSTVETO
Definition: LArEventBitInfo.h:13
TrigMETMonitorAlgorithm::~TrigMETMonitorAlgorithm
virtual ~TrigMETMonitorAlgorithm()
Definition: TrigMETMonitorAlgorithm.cxx:16
TrigMETMonitorAlgorithm::m_l1_gFexJwojMHTComponents_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexJwojMHTComponents_key
Definition: TrigMETMonitorAlgorithm.h:63
lumiFormat.i
int i
Definition: lumiFormat.py:85
TrigMETMonitorAlgorithm::m_hlt_mhtpufit_pf_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_mhtpufit_pf_met_key
Definition: TrigMETMonitorAlgorithm.h:83
TrigMETMonitorAlgorithm::m_algsHLTExpert
Gaudi::Property< std::vector< std::string > > m_algsHLTExpert
Definition: TrigMETMonitorAlgorithm.h:98
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:28
TrigMETMonitorAlgorithm::m_l1_gFexJwojMETComponents_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexJwojMETComponents_key
Definition: TrigMETMonitorAlgorithm.h:62
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
TrigMETMonitorAlgorithm::m_hlt_mhtpufit_em_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_mhtpufit_em_met_key
Definition: TrigMETMonitorAlgorithm.h:84
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
xAOD::MissingET_v1
Principal data object for Missing ET.
Definition: MissingET_v1.h:25
xAOD::MissingET_v1::mpx
float mpx() const
Returns .
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigMETMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: TrigMETMonitorAlgorithm.cxx:19
TrigMETMonitorAlgorithm::m_l1_jFexMet_key
SG::ReadHandleKey< xAOD::jFexMETRoIContainer > m_l1_jFexMet_key
Definition: TrigMETMonitorAlgorithm.h:59
TrigMETMonitorAlgorithm::m_algsHLT
Gaudi::Property< std::vector< std::string > > m_algsHLT
Definition: TrigMETMonitorAlgorithm.h:94
TrigMETMonitorAlgorithm::m_hltChainsVal
Gaudi::Property< std::vector< std::string > > m_hltChainsVal
Definition: TrigMETMonitorAlgorithm.h:89
TrigMETMonitorAlgorithm::m_L1MetAlg
Gaudi::Property< int > m_L1MetAlg
Definition: TrigMETMonitorAlgorithm.h:103
xAOD::Vertex_v1::z
float z() const
Returns the z position.
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TrigMETMonitorAlgorithm::m_hlt_electron_key
SG::ReadHandleKey< xAOD::ElectronContainer > m_hlt_electron_key
Definition: TrigMETMonitorAlgorithm.h:49
TrigMETMonitorAlgorithm::m_hlt_tc_em_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_tc_em_met_key
Definition: TrigMETMonitorAlgorithm.h:73
Electron
TrigMETMonitorAlgorithm::m_hlt_pfsum_cssk_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_pfsum_cssk_met_key
Definition: TrigMETMonitorAlgorithm.h:78
xAOD::EnergySumRoI_v2::energyX
float energyX() const
The total energy deposited in the X direction.
TrigMETMonitorAlgorithm::m_l1_gFexRhoMETScalar_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexRhoMETScalar_key
Definition: TrigMETMonitorAlgorithm.h:67
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TrigMETMonitorAlgorithm::m_lvl1_roi_key
SG::ReadHandleKey< xAOD::EnergySumRoI > m_lvl1_roi_key
Definition: TrigMETMonitorAlgorithm.h:57
TrigMETMonitorAlgorithm::m_hlt_tc_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_tc_met_key
Definition: TrigMETMonitorAlgorithm.h:72
TrigMETMonitorAlgorithm::m_offline_vertex_key
SG::ReadHandleKey< xAOD::VertexContainer > m_offline_vertex_key
Definition: TrigMETMonitorAlgorithm.h:55
TrigMETMonitorAlgorithm::m_hltChains
Gaudi::Property< std::vector< std::string > > m_hltChains
Definition: TrigMETMonitorAlgorithm.h:88
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
RegSelToolConfig.alg
alg
Definition: RegSelToolConfig.py:332
TrigMETMonitorAlgorithm::m_hlt_tcpufit_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_tcpufit_met_key
Definition: TrigMETMonitorAlgorithm.h:74
TrigMETMonitorAlgorithm::m_vertex_key
SG::ReadHandleKey< xAOD::VertexContainer > m_vertex_key
Definition: TrigMETMonitorAlgorithm.h:54
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
python.PyAthena.v
v
Definition: PyAthena.py:154
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
TrigMETMonitorAlgorithm::m_l1_gFexNCMETScalar_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexNCMETScalar_key
Definition: TrigMETMonitorAlgorithm.h:65
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
TrigMETMonitorAlgorithm::m_l1_gFexRhoMETComponents_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexRhoMETComponents_key
Definition: TrigMETMonitorAlgorithm.h:68
TrigMETMonitorAlgorithm::m_hlt_mht_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_mht_met_key
Definition: TrigMETMonitorAlgorithm.h:71
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TrigMETMonitorAlgorithm::m_compNames
Gaudi::Property< std::vector< std::string > > m_compNames
Definition: TrigMETMonitorAlgorithm.h:100
xAOD::TrigMissingET_v1
Class holding the Missing ET trigger fex results.
Definition: TrigMissingET_v1.h:32
xAOD::TrigMissingET_v1::eyComponent
float eyComponent(unsigned int index) const
Get the y component fo the energy of a component.
Definition: TrigMissingET_v1.cxx:130
xAOD::TrigMissingET_v1::ey
float ey() const
Get the y component of the missing energy.
TrigMETMonitorAlgorithm.h
xAOD::EventInfo_v1::isEventFlagBitSet
bool isEventFlagBitSet(EventFlagSubDet subDet, size_t bit) const
Check one particular bit of one particular sub-detector.
Definition: EventInfo_v1.cxx:703
xAOD::TrigMissingET_v1::ez
float ez() const
Get the z component of the missing energy.
TrigMETMonitorAlgorithm::m_algsL1
Gaudi::Property< std::vector< std::string > > m_algsL1
Definition: TrigMETMonitorAlgorithm.h:93
TrigMETMonitorAlgorithm::m_topoclusters_key
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_topoclusters_key
Definition: TrigMETMonitorAlgorithm.h:52
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
TrigMETMonitorAlgorithm::m_algsHLTPreSel
Gaudi::Property< std::vector< std::string > > m_algsHLTPreSel
Definition: TrigMETMonitorAlgorithm.h:95
xAOD::MissingET_v1::mpy
float mpy() const
Returns .
TrigMETMonitorAlgorithm::m_l1_jFexSumEt_key
SG::ReadHandleKey< xAOD::jFexSumETRoIContainer > m_l1_jFexSumEt_key
Definition: TrigMETMonitorAlgorithm.h:60
TrigMETMonitorAlgorithm::m_hlt_muon_key
SG::ReadHandleKey< xAOD::MuonContainer > m_hlt_muon_key
Definition: TrigMETMonitorAlgorithm.h:50
TrigMETMonitorAlgorithm::m_hlt_pfsum_vssk_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_pfsum_vssk_met_key
Definition: TrigMETMonitorAlgorithm.h:79
TrigMETMonitorAlgorithm::m_hltChainMu
Gaudi::Property< std::vector< std::string > > m_hltChainMu
Definition: TrigMETMonitorAlgorithm.h:92
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TrigMETMonitorAlgorithm::m_tracks_key
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_tracks_key
Definition: TrigMETMonitorAlgorithm.h:53
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(const std::string &name) const
Get a specific monitoring tool from the tool handle array.
Definition: AthMonitorAlgorithm.cxx:164
TrigMETMonitorAlgorithm::m_offline_met_key
SG::ReadHandleKey< xAOD::MissingETContainer > m_offline_met_key
Definition: TrigMETMonitorAlgorithm.h:47
xAOD::EventInfo_v1::actualInteractionsPerCrossing
float actualInteractionsPerCrossing() const
Average interactions per crossing for the current BCID - for in-time pile-up.
Definition: EventInfo_v1.cxx:380
TrigMETMonitorAlgorithm::m_L1MetCut
Gaudi::Property< double > m_L1MetCut
Definition: TrigMETMonitorAlgorithm.h:104
Generated on Tue Oct 28 2025 21:22:26 for ATLAS Offline Software by   doxygen 1.8.18