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