ATLAS Offline Software
TrigTauMonitorSingleAlgorithm.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "TrigTauMonitorSingleAlgorithm.h"
6 
7 #include "StoreGate/ReadDecorHandle.h"
8 
9 
10 TrigTauMonitorSingleAlgorithm::TrigTauMonitorSingleAlgorithm(const std::string& name, ISvcLocator* pSvcLocator)
11  : TrigTauMonitorBaseAlgorithm(name, pSvcLocator)
12 {}
13 
14 
15 StatusCode TrigTauMonitorSingleAlgorithm::initialize()
16 {
17  ATH_CHECK( TrigTauMonitorBaseAlgorithm::initialize() );
18 
19  // Create the TauID score decor handle keys for the Monitoring...
20  for(const auto& [seq_name, m] : m_monitoredHLTIdScores) {
21  const std::string online_container_name = getOnlineContainerKey(seq_name).key();
22  for(const auto& [key, p] : m) {
23  if(p.first.empty() || p.second.empty()) {
24  ATH_MSG_WARNING("Invalid HLT TauID score variable names; skipping this entry for the monitoring!");
25  continue;
26  }
27 
28  m_monitoredHLTIdDecorHandleKeys[seq_name].emplace(
29  key,
30  std::make_pair(
31  SG::ReadDecorHandleKey<xAOD::TauJetContainer>(online_container_name + "." + p.first),
32  SG::ReadDecorHandleKey<xAOD::TauJetContainer>(online_container_name + "." + p.second)
33  )
34  );
35  ATH_CHECK(m_monitoredHLTIdDecorHandleKeys.at(seq_name).at(key).first.initialize());
36  ATH_CHECK(m_monitoredHLTIdDecorHandleKeys.at(seq_name).at(key).second.initialize());
37  }
38  }
39 
40  for(const auto& [key, p] : m_monitoredOfflineIdScores) {
41  if(p.first.empty() || p.second.empty()) {
42  ATH_MSG_WARNING("Invalid Offline TauID score variable names; skipping this entry for the monitoring!");
43  continue;
44  }
45 
46  m_monitoredOfflineIdDecorHandleKeys.emplace(
47  key,
48  std::make_pair(
49  SG::ReadDecorHandleKey<xAOD::TauJetContainer>(m_offlineTauJetKey.key() + "." + p.first),
50  SG::ReadDecorHandleKey<xAOD::TauJetContainer>(m_offlineTauJetKey.key() + "." + p.second)
51  )
52  );
53  ATH_CHECK(m_monitoredOfflineIdDecorHandleKeys.at(key).first.initialize());
54  ATH_CHECK(m_monitoredOfflineIdDecorHandleKeys.at(key).second.initialize());
55  }
56 
57  return StatusCode::SUCCESS;
58 }
59 
60 
61 StatusCode TrigTauMonitorSingleAlgorithm::processEvent(const EventContext& ctx) const
62 {
63  constexpr float threshold_offset = 10.0;
64 
65  // Offline taus
66  auto offline_taus_all = getOfflineTausAll(ctx, 0.0);
67  if(m_requireOfflineTaus && offline_taus_all.empty()) return StatusCode::SUCCESS;
68 
69  for(const std::string& trigger : m_triggers) {
70  const TrigTauInfo& info = getTrigInfo(trigger);
71 
72  if(!info.isHLTSingleTau()) {
73  ATH_MSG_WARNING("Chain \"" << trigger << "\" is not a single tau trigger. Skipping...");
74  continue;
75  }
76 
77  const auto passBits = m_trigDecTool->isPassedBits(trigger);
78  const bool l1_accept_flag = passBits & TrigDefs::L1_isPassedAfterVeto;
79  const bool hlt_not_prescaled_flag = (passBits & TrigDefs::EF_prescaled) == 0;
80 
81  // Offline tau requirement check
82  const std::vector<const xAOD::TauJet*> offline_taus_with_id = classifyTausAll(offline_taus_all, 0, static_cast<TauID>(m_offline_tau_id.value()));
83  if(m_requireOfflineTaus && offline_taus_with_id.empty()) continue;
84 
85  // Filter offline taus
86  auto offline_taus = classifyOfflineTaus(offline_taus_with_id, info.getHLTTauThreshold() - threshold_offset);
87  std::vector<const xAOD::TauJet*> offline_taus_1p = offline_taus.first;
88  std::vector<const xAOD::TauJet*> offline_taus_3p = offline_taus.second;
89 
90  // Online taus
91  std::vector<const xAOD::TauJet*> hlt_taus_all = getOnlineTausAll(trigger, true);
92  auto hlt_taus = classifyOnlineTaus(hlt_taus_all);
93  std::vector<const xAOD::TauJet*> hlt_taus_0p = std::get<0>(hlt_taus);
94  std::vector<const xAOD::TauJet*> hlt_taus_1p = std::get<1>(hlt_taus);
95  std::vector<const xAOD::TauJet*> hlt_taus_mp = std::get<2>(hlt_taus);
96 
97  if(m_do_variable_plots) {
98  // Offline variables:
99  if(m_doOfflineTausDistributions && !offline_taus_1p.empty()) {
100  fillBasicVars(ctx, trigger, offline_taus_1p, "1P", false);
101  fillIDScores(ctx, trigger, offline_taus_1p, "1P", false);
102  fillIDInputVars(trigger, offline_taus_1p, "1P", false);
103  fillIDTrack(trigger, offline_taus_1p, false);
104  fillIDCluster(trigger, offline_taus_1p, false);
105  }
106  if(m_doOfflineTausDistributions && !offline_taus_3p.empty()) {
107  fillBasicVars(ctx, trigger, offline_taus_3p, "3P", false);
108  fillIDScores(ctx, trigger, offline_taus_3p, "3P", false);
109  fillIDInputVars(trigger, offline_taus_3p, "3P", false);
110  fillIDTrack(trigger, offline_taus_3p, false);
111  fillIDCluster(trigger, offline_taus_3p, false);
112  }
113 
114  // Fill information for online 0 prong taus
115  if(!hlt_taus_0p.empty()) {
116  fillBasicVars(ctx, trigger, hlt_taus_0p, "0P", true);
117  fillIDScores(ctx, trigger, hlt_taus_0p, "0P", true);
118  fillIDInputVars(trigger, hlt_taus_0p, "0P", true);
119  fillIDTrack(trigger, hlt_taus_0p, true);
120  fillIDCluster(trigger, hlt_taus_0p, true);
121  }
122 
123  // Fill information for online 1 prong taus
124  if(!hlt_taus_1p.empty()) {
125  fillBasicVars(ctx, trigger, hlt_taus_1p, "1P", true);
126  fillIDScores(ctx, trigger, hlt_taus_1p, "1P", true);
127  fillIDInputVars(trigger, hlt_taus_1p, "1P", true);
128  fillIDTrack(trigger, hlt_taus_1p, true);
129  fillIDCluster(trigger, hlt_taus_1p, true);
130  }
131 
132  // Fill information for online multiprong prong taus
133  if(!hlt_taus_mp.empty()) {
134  fillBasicVars(ctx, trigger, hlt_taus_mp, "MP", true);
135  fillIDScores(ctx, trigger, hlt_taus_mp, "MP", true);
136  fillIDInputVars(trigger, hlt_taus_mp, "MP", true);
137  fillIDTrack(trigger, hlt_taus_mp, true);
138  fillIDCluster(trigger, hlt_taus_mp, true);
139  }
140  }
141 
142  if(m_do_efficiency_plots && hlt_not_prescaled_flag) {
143  fillHLTEfficiencies(ctx, trigger, l1_accept_flag, offline_taus_1p, hlt_taus_all, "1P");
144  fillHLTEfficiencies(ctx, trigger, l1_accept_flag, offline_taus_3p, hlt_taus_all, "3P");
145  }
146  }
147 
148  return StatusCode::SUCCESS;
149 }
150 
151 
152 void TrigTauMonitorSingleAlgorithm::fillHLTEfficiencies(const EventContext& ctx, const std::string& trigger, const bool l1_accept_flag, const std::vector<const xAOD::TauJet*>& offline_tau_vec, const std::vector<const xAOD::TauJet*>& online_tau_vec, const std::string& nProng) const
153 {
154  ATH_MSG_DEBUG("Fill HLT " << nProng << " efficiencies: " << trigger);
155 
156  const TrigTauInfo& info = getTrigInfo(trigger);
157 
158  // Efficiency for single leg tau triggers:
159  // denominator = offline tau + matching with L1 object with dR(offline tau,L1 item) < 0.3
160  // numerator = denominator + hlt fires + matching with HLT tau with dR(offline tau, HLT tau) < 0.2
161 
162  auto monGroup = getGroup(trigger+"_HLT_Efficiency_"+nProng);
163 
164  auto tauPt = Monitored::Scalar<float>("tauPt", 0.0);
165  auto tauEta = Monitored::Scalar<float>("tauEta", 0.0);
166  auto tauPhi = Monitored::Scalar<float>("tauPhi", 0.0);
167  auto averageMu = Monitored::Scalar<float>("averageMu", 0.0);
168  auto HLT_match = Monitored::Scalar<bool>("HLT_pass", false);
169  auto HLT_match_highPt = Monitored::Scalar<bool>("HLT_pass_highPt", false);
170  auto Total_match = Monitored::Scalar<bool>("Total_pass", false);
171  auto Total_match_highPt = Monitored::Scalar<bool>("Total_pass_highPt", false);
172 
173  bool hlt_fires = m_trigDecTool->isPassed(trigger, TrigDefs::Physics | TrigDefs::allowResurrectedDecision);
174 
175  std::vector<TLorentzVector> rois = getRoIsVector(ctx, trigger);
176  for(const auto *offline_tau : offline_tau_vec) {
177  bool L1_match = false;
178 
179  // Check the matching offline tau with L1 item -> depending on the L1 type (phase-1 eTAU, jTAU, cTAU)
180  // All L1 RoIs have a core size of 3x3 TTs -> 0.3 x 0.3
181  for(const TLorentzVector& roi : rois) {
182  L1_match = offline_tau->p4().DeltaR(roi) <= 0.3;
183  if(L1_match) break;
184  }
185 
186  tauPt = offline_tau->pt()/Gaudi::Units::GeV;
187  tauEta = offline_tau->eta();
188  tauPhi = offline_tau->phi();
189  averageMu = lbAverageInteractionsPerCrossing(ctx);
190 
191  bool is_highPt = tauPt > info.getHLTTauThreshold() + 20.0;
192 
193  // HLT matching: dR matching + HLT fires
194  HLT_match = matchObjects(offline_tau, online_tau_vec, 0.2) && hlt_fires;
195 
196  // Total efficiency (without L1 matching)
197  if(m_doTotalEfficiency) {
198  Total_match = static_cast<bool>(HLT_match);
199  fill(monGroup, tauPt, tauEta, tauPhi, Total_match);
200 
201  if(is_highPt) {
202  Total_match_highPt = static_cast<bool>(HLT_match);
203  fill(monGroup, tauEta, tauPhi, Total_match_highPt);
204  }
205  }
206 
207  if(!L1_match || !l1_accept_flag) continue; // Skip this offline tau since not matched with L1 item
208 
209  fill(monGroup, tauPt, tauEta, tauPhi, averageMu, HLT_match);
210 
211  if(is_highPt) {
212  HLT_match_highPt = static_cast<bool>(HLT_match);
213  fill(monGroup, tauEta, tauPhi, HLT_match_highPt);
214  }
215  }
216 
217  ATH_MSG_DEBUG("After fill HLT efficiencies: " << trigger);
218 }
219 
220 
221 void TrigTauMonitorSingleAlgorithm::fillIDInputVars(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec,const std::string& nProng, bool online) const
222 {
223  ATH_MSG_DEBUG("Fill ID input variables: " << trigger);
224 
225  auto monGroup = getGroup(trigger+"_ID_"+(online ? "HLT" : "Offline")+"_InputScalar_"+nProng);
226 
227  auto centFrac = Monitored::Collection("centFrac", tau_vec, [](const xAOD::TauJet* tau){
228  float detail = -999;
229  if(tau->detail(xAOD::TauJetParameters::centFrac, detail)) detail = std::min(detail, 1.0f);
230  return detail;
231  });
232  auto etOverPtLeadTrk = Monitored::Collection("etOverPtLeadTrk", tau_vec, [](const xAOD::TauJet* tau){
233  float detail = -999;
234  if(tau->detail(xAOD::TauJetParameters::etOverPtLeadTrk, detail)) detail = std::log10(std::max(detail, 0.1f));
235  return detail;
236  });
237  auto dRmax = Monitored::Collection("dRmax", tau_vec, [](const xAOD::TauJet* tau){
238  float detail = -999;
239  tau->detail(xAOD::TauJetParameters::dRmax, detail);
240  return detail;
241  });
242  auto absipSigLeadTrk = Monitored::Collection("absipSigLeadTrk", tau_vec, [](const xAOD::TauJet* tau){
243  float detail = (tau->nTracks()>0) ? std::abs(tau->track(0)->d0SigTJVA()) : 0;
244  detail = std::min(std::abs(detail), 30.0f);
245  return detail;
246  });
247  auto sumPtTrkFrac = Monitored::Collection("sumPtTrkFrac", tau_vec, [](const xAOD::TauJet* tau){
248  float detail = -999;
249  tau->detail(xAOD::TauJetParameters::SumPtTrkFrac, detail);
250  return detail;
251  });
252  auto emPOverTrkSysP = Monitored::Collection("emPOverTrkSysP", tau_vec, [](const xAOD::TauJet* tau){
253  float detail = -999;
254  if(tau->detail(xAOD::TauJetParameters::EMPOverTrkSysP, detail)) detail = std::log10(std::max(detail, 1e-3f));
255  return detail;
256  });
257  auto ptRatioEflowApprox = Monitored::Collection("ptRatioEflowApprox", tau_vec, [](const xAOD::TauJet* tau){
258  float detail = -999;
259  if(tau->detail(xAOD::TauJetParameters::ptRatioEflowApprox, detail)) detail = std::min(detail, 4.0f);
260  return detail;
261  });
262  auto mEflowApprox = Monitored::Collection("mEflowApprox", tau_vec, [](const xAOD::TauJet* tau){
263  float detail = -999;
264  if(tau->detail(xAOD::TauJetParameters::mEflowApprox, detail)) detail = std::log10(std::max(detail, 140.0f));
265  return detail;
266  });
267  auto ptDetectorAxis = Monitored::Collection("ptDetectorAxis", tau_vec, [](const xAOD::TauJet* tau){
268  float detail = -999;
269  if( tau->ptDetectorAxis() > 0) detail = std::log10(std::min(tau->ptDetectorAxis()/Gaudi::Units::GeV, 100.0));
270  return detail;
271  });
272  auto massTrkSys = Monitored::Collection("massTrkSys", tau_vec, [&nProng](const xAOD::TauJet* tau){
273  float detail = -999;
274  if( tau->detail(xAOD::TauJetParameters::massTrkSys, detail) && (nProng.find("MP") != std::string::npos || nProng.find("3P") != std::string::npos)) {
275  detail = std::log10(std::max(detail, 140.0f));
276  }
277  return detail;});
278  auto trFlightPathSig = Monitored::Collection("trFlightPathSig", tau_vec, [&nProng](const xAOD::TauJet* tau){
279  float detail = -999;
280  if(nProng.find("MP") != std::string::npos || nProng.find("3P") != std::string::npos) tau->detail(xAOD::TauJetParameters::trFlightPathSig, detail);
281  return detail;
282  });
283 
284  fill(monGroup, centFrac, etOverPtLeadTrk, dRmax, absipSigLeadTrk, sumPtTrkFrac, emPOverTrkSysP, ptRatioEflowApprox, mEflowApprox, ptDetectorAxis, massTrkSys, trFlightPathSig);
285 
286  ATH_MSG_DEBUG("After fill ID input variables: " << trigger);
287 }
288 
289 
290 void TrigTauMonitorSingleAlgorithm::fillIDTrack(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const
291 {
292  ATH_MSG_DEBUG("Fill ID input Track: " << trigger);
293 
294  auto monGroup = getGroup(trigger+"_ID_"+(online ? "HLT" : "Offline")+"_InputTrack");
295 
296  auto track_pt_jetseed_log = Monitored::Collection("track_pt_jetseed_log", tau_vec, [](const xAOD::TauJet* tau){ return std::log10(tau->ptJetSeed()); });
297  fill(monGroup, track_pt_jetseed_log);
298 
299  for(const auto *tau : tau_vec) {
300  // Don't call ->allTracks() unless the element links are valid
301  static const SG::ConstAccessor< std::vector<ElementLink<xAOD::TauTrackContainer>> > tauTrackAcc("tauTrackLinks");
302  bool linksValid = true;
303  for(const ElementLink<xAOD::TauTrackContainer>& trackEL : tauTrackAcc(*tau)) {
304  if(!trackEL.isValid()) {
305  linksValid = false;
306  break;
307  }
308  }
309  if(!linksValid) {
310  ATH_MSG_WARNING("Invalid track element links from TauJet in " << trigger);
311  continue;
312  }
313 
314  auto tracks = tau->allTracks();
315  std::sort(tracks.begin(), tracks.end(), [](const xAOD::TauTrack* lhs, const xAOD::TauTrack* rhs){ return lhs->pt() > rhs->pt(); });
316 
317  auto n_track = Monitored::Scalar<int>("n_track", tracks.size());
318 
319  auto track_pt_log = Monitored::Collection("track_pt_log", tracks, [](const xAOD::TauTrack *track){ return std::log10(track->pt()); });
320  auto track_eta = Monitored::Collection("track_eta", tracks, [](const xAOD::TauTrack *track){ return track->eta(); });
321  auto track_phi = Monitored::Collection("track_phi", tracks, [](const xAOD::TauTrack *track){ return track->phi(); });
322 
323  auto track_dEta = Monitored::Collection("track_dEta", tracks, [&tau](const xAOD::TauTrack *track){ return track->eta() - tau->eta(); });
324  auto track_dPhi = Monitored::Collection("track_dPhi", tracks, [&tau](const xAOD::TauTrack *track){ return track->p4().DeltaPhi(tau->p4()); });
325 
326  auto track_z0sinthetaTJVA_abs_log = Monitored::Collection("track_z0sinthetaTJVA_abs_log", tracks, [](const xAOD::TauTrack *track){return track->z0sinthetaTJVA(); });
327  auto track_d0_abs_log = Monitored::Collection("track_d0_abs_log", tracks, [](const xAOD::TauTrack *track){ return std::log10(std::abs(track->track()->d0()) + 1e-6); });
328 
329  auto track_nIBLHitsAndExp = Monitored::Collection("track_nIBLHitsAndExp", tracks, [](const xAOD::TauTrack *track){
330  uint8_t inner_pixel_hits, inner_pixel_exp;
331  const auto success1_innerPixel_hits = track->track()->summaryValue(inner_pixel_hits, xAOD::numberOfInnermostPixelLayerHits);
332  const auto success2_innerPixel_exp = track->track()->summaryValue(inner_pixel_exp, xAOD::expectInnermostPixelLayerHit);
333  float detail = -999;
334  if(success1_innerPixel_hits && success2_innerPixel_exp) { detail = inner_pixel_exp ? inner_pixel_hits : 1.; };
335  return detail;
336  });
337  auto track_nPixelHitsPlusDeadSensors = Monitored::Collection("track_nPixelHitsPlusDeadSensors", tracks, [](const xAOD::TauTrack *track){
338  uint8_t pixel_hits, pixel_dead;
339  const auto success1_pixel_hits = track->track()->summaryValue(pixel_hits, xAOD::numberOfPixelHits);
340  const auto success2_pixel_dead = track->track()->summaryValue(pixel_dead, xAOD::numberOfPixelDeadSensors);
341  float detail = -999;
342  if(success1_pixel_hits && success2_pixel_dead) { detail = pixel_hits + pixel_dead; };
343  return detail;
344  });
345  auto track_nSCTHitsPlusDeadSensors = Monitored::Collection("track_nSCTHitsPlusDeadSensors", tracks, [](const xAOD::TauTrack *track){
346  uint8_t sct_hits, sct_dead;
347  const auto success1_sct_hits = track->track()->summaryValue(sct_hits, xAOD::numberOfSCTHits);
348  const auto success2_sct_dead = track->track()->summaryValue(sct_dead, xAOD::numberOfSCTDeadSensors);
349  float detail = -999;
350  if(success1_sct_hits && success2_sct_dead) { detail = sct_hits + sct_dead; };
351  return detail;
352  });
353 
354  fill(monGroup, n_track, track_pt_log, track_eta, track_phi, track_dEta, track_dPhi, track_z0sinthetaTJVA_abs_log, track_d0_abs_log, track_nIBLHitsAndExp, track_nPixelHitsPlusDeadSensors, track_nSCTHitsPlusDeadSensors);
355  }
356 
357  ATH_MSG_DEBUG("After fill ID input Track: " << trigger);
358 }
359 
360 
361 void TrigTauMonitorSingleAlgorithm::fillIDCluster(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const
362 {
363  ATH_MSG_DEBUG("Fill ID input Cluster: " << trigger << " for online/offline " << online);
364 
365  auto monGroup = getGroup(trigger+"_ID_"+(online ? "HLT" : "Offline")+"_InputCluster");
366 
367  for(const auto *tau : tau_vec){
368  auto cluster_pt_jetseed_log = Monitored::Collection("cluster_pt_jetseed_log", tau_vec, [](const xAOD::TauJet* tau){ return std::log10(tau->ptJetSeed()); });
369 
370  std::vector<const xAOD::CaloCluster*> clusters;
371  for(const xAOD::IParticle* particle : tau->clusters()) {
372  const xAOD::CaloCluster* cluster = static_cast<const xAOD::CaloCluster*>(particle);
373  clusters.push_back(cluster);
374  }
375  std::sort(clusters.begin(), clusters.end(), [](const xAOD::CaloCluster *lhs, const xAOD::CaloCluster *rhs){ return lhs->et() > rhs->et(); });
376 
377  auto n_cluster = Monitored::Scalar<int>("n_cluster", 0);
378  n_cluster = clusters.size();
379 
380  auto cluster_et_log = Monitored::Collection("cluster_et_log",clusters, [](const xAOD::CaloCluster *cluster){ return std::log10( cluster->et()); });
381  auto cluster_eta = Monitored::Collection("cluster_eta", clusters, [](const xAOD::CaloCluster *cluster){ return cluster->eta(); });
382  auto cluster_phi = Monitored::Collection("cluster_phi", clusters, [](const xAOD::CaloCluster *cluster){ return cluster->phi(); });
383  auto cluster_dEta = Monitored::Collection("cluster_dEta", clusters, [&tau](const xAOD::CaloCluster *cluster){ return cluster->eta() - tau->eta(); });
384  auto cluster_dPhi = Monitored::Collection("cluster_dPhi", clusters, [&tau](const xAOD::CaloCluster *cluster){ return cluster->p4().DeltaPhi(tau->p4()); });
385  auto cluster_SECOND_R_log10 = Monitored::Collection("cluster_SECOND_R_log10", clusters, [](const xAOD::CaloCluster *cluster){
386  double detail = -999;
387  const auto success_SECOND_R = cluster->retrieveMoment(xAOD::CaloCluster::MomentType::SECOND_R,detail);
388  if(success_SECOND_R) detail = std::log10(detail + 0.1);
389  return detail;
390  });
391 
392  auto cluster_SECOND_LAMBDA_log10 = Monitored::Collection("cluster_SECOND_LAMBDA_log10", clusters, [](const xAOD::CaloCluster *cluster){
393  double detail = -999;
394  const auto success_SECOND_LAMBDA = cluster->retrieveMoment(xAOD::CaloCluster::MomentType::SECOND_LAMBDA, detail);
395  if(success_SECOND_LAMBDA) detail = std::log10(detail + 0.1);
396  return detail;
397  });
398 
399  auto cluster_CENTER_LAMBDA_log10 = Monitored::Collection("cluster_CENTER_LAMBDA_log10", clusters, [](const xAOD::CaloCluster *cluster){
400  double detail = -999;
401  const auto success_CENTER_LAMBDA = cluster->retrieveMoment(xAOD::CaloCluster::MomentType::CENTER_LAMBDA, detail);
402  if(success_CENTER_LAMBDA) detail = std::log10(detail + 1e-6);
403  return detail;
404  });
405 
406  fill(monGroup, n_cluster, cluster_pt_jetseed_log, cluster_et_log, cluster_eta, cluster_phi, cluster_dEta, cluster_dPhi, cluster_SECOND_R_log10, cluster_SECOND_LAMBDA_log10, cluster_CENTER_LAMBDA_log10);
407  }
408 
409  ATH_MSG_DEBUG("After fill ID input Cluster: " << trigger);
410 }
411 
412 
413 void TrigTauMonitorSingleAlgorithm::fillBasicVars(const EventContext& ctx, const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, const std::string& nProng, bool online) const
414 {
415  ATH_MSG_DEBUG("Fill Basic Variables: " << trigger);
416 
417  auto monGroup = getGroup(trigger+"_"+(online ? "HLT" : "Offline")+"_basicVars_"+nProng);
418 
419  auto Pt = Monitored::Collection("Pt", tau_vec, [](const xAOD::TauJet* tau){ return tau->pt()/Gaudi::Units::GeV; });
420  auto Eta = Monitored::Collection("Eta", tau_vec, [](const xAOD::TauJet* tau){ return tau->eta(); });
421  auto Phi = Monitored::Collection("Phi", tau_vec, [](const xAOD::TauJet* tau){ return tau->phi(); });
422 
423  auto nTrack = Monitored::Collection("nTrack", tau_vec, [](const xAOD::TauJet* tau){
424  int nTrack = -1;
425  tau->detail(xAOD::TauJetParameters::nChargedTracks, nTrack);
426  return nTrack;
427  });
428  auto nIsoTrack = Monitored::Collection("nIsoTrack", tau_vec, [](const xAOD::TauJet* tau){ return tau->nTracksIsolation(); });
429 
430  auto averageMu = Monitored::Scalar<float>("averageMu", 0.0);
431  averageMu = lbAverageInteractionsPerCrossing(ctx);
432 
433  auto TauVertexX = Monitored::Collection("TauVertexX", tau_vec, [](const xAOD::TauJet* tau){
434  double vtx = -999;
435  if(tau->vertex() != nullptr) vtx = tau->vertex()->x();
436  return vtx;
437  });
438  auto TauVertexY = Monitored::Collection("TauVertexY", tau_vec, [](const xAOD::TauJet* tau){
439  double vty = -999;
440  if(tau->vertex() != nullptr) vty = tau->vertex()->y();
441  return vty;
442  });
443  auto TauVertexZ = Monitored::Collection("TauVertexZ", tau_vec, [](const xAOD::TauJet* tau){
444  double vtz = -999;
445  if(tau->vertex() != nullptr) vtz = tau->vertex()->z();
446  return vtz;
447  });
448 
449  fill(monGroup, Pt, Eta, Phi, nTrack, nIsoTrack, averageMu, TauVertexX, TauVertexY, TauVertexZ);
450 
451  ATH_MSG_DEBUG("After fill Basic variables: " << trigger);
452 }
453 
454 
455 void TrigTauMonitorSingleAlgorithm::fillIDScores(const EventContext& ctx, const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, const std::string& nProng, bool online) const
456 {
457  ATH_MSG_DEBUG("Fill TauID Scores: " << trigger);
458 
459  const TrigTauInfo& info = getTrigInfo(trigger);
460  const std::string tau_id = info.getHLTTauID();
461  bool store_all = tau_id == "idperf" || tau_id == "perf";
462 
463  if(online) {
464  if(m_monitoredHLTIdDecorHandleKeys.find(info.getHLTTauType()) == m_monitoredHLTIdDecorHandleKeys.end()) return;
465  } else {
466  if(m_monitoredOfflineIdDecorHandleKeys.size() == 0) return;
467  }
468 
469 
470  const auto& decor_handle_keys = online ? m_monitoredHLTIdDecorHandleKeys.at(info.getHLTTauType()) : m_monitoredOfflineIdDecorHandleKeys;
471 
472  // This has to be down here, because otherwise we crash on unmonitored chains
473  auto monGroup = getGroup(trigger+"_"+(online ? "HLT" : "Offline")+"_IDScores_"+nProng);
474 
475  for(const auto& [key, p] : decor_handle_keys) {
476  // We will either store the TauID scores indicated in the chain name, or all of them in case of (id)perf chains
477  if(online && !store_all && tau_id != key) continue;
478 
479  SG::ReadDecorHandle<xAOD::TauJetContainer, float> score_handle(p.first, ctx);
480  SG::ReadDecorHandle<xAOD::TauJetContainer, float> score_sig_trans_handle(p.second, ctx);
481 
482  // Skip if both the Score and ScoreSigTrans aren't available
483  if(!score_handle.isAvailable() || !score_sig_trans_handle.isAvailable()) continue;
484 
485  std::vector<float> score, score_sig_trans;
486  for(const xAOD::TauJet* tau : tau_vec) {
487  score.push_back(score_handle(*tau));
488  score_sig_trans.push_back(score_sig_trans_handle(*tau));
489  }
490 
491  auto IDScore = Monitored::Collection(key + "_TauIDScore", score);
492  auto IDScoreSigTrans = Monitored::Collection(key + "_TauIDScoreSigTrans", score_sig_trans);
493  fill(monGroup, IDScore, IDScoreSigTrans);
494  }
495 
496  ATH_MSG_DEBUG("After fill TauID Scores: " << trigger);
497 }
498 
499 
500 std::vector<TLorentzVector> TrigTauMonitorSingleAlgorithm::getRoIsVector(const EventContext& ctx, const std::string& trigger) const
501 {
502  std::vector<TLorentzVector> ret;
503 
504  const TrigTauInfo& info = getTrigInfo(trigger);
505 
506  TLorentzVector v;
507  if(info.getL1TauType() == "eTAU") {
508  for(const xAOD::eFexTauRoI* roi : getL1eTAUs(ctx, info.getL1TauItem())) {
509  v.SetPtEtaPhiM(roi->et(), roi->eta(), roi->phi(), 0);
510  ret.push_back(v);
511  }
512  } else if(info.getL1TauType() == "jTAU") {
513  for(const xAOD::jFexTauRoI* roi : getL1jTAUs(ctx, info.getL1TauItem())) {
514  v.SetPtEtaPhiM(roi->et(), roi->eta(), roi->phi(), 0);
515  ret.push_back(v);
516  }
517  } else if(info.getL1TauType() == "cTAU") {
518  for(const auto& [eTau_roi, jTau_roi] : getL1cTAUs(ctx, info.getL1TauItem())) {
519  v.SetPtEtaPhiM(eTau_roi->et(), eTau_roi->eta(), eTau_roi->phi(), 0);
520  ret.push_back(v);
521  }
522  }
523 
524  return ret;
525 }
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xAOD::jFexTauRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexTauRoI_v1.h:23
xAOD::Vertex_v1::x
float x() const
Returns the x position.
python.TIDAMonTool.monGroup
def monGroup(analysis_chain)
Definition: TIDAMonTool.py:301
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:18
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:79
TrigTauMonitorBaseAlgorithm::TauID
TauID
Definition: TrigTauMonitorBaseAlgorithm.h:30
TauAnalysisTools::tauEta
double tauEta(const xAOD::TauJet &xTau)
return tau eta
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:100
xAOD::TauJetParameters::trFlightPathSig
@ trFlightPathSig
Definition: TauDefs.h:163
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
xAOD::TauTrack_v1::d0SigTJVA
float d0SigTJVA() const
Definition: TauTrack_v1.cxx:120
xAOD::TauJet_v3::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
TrigTauMonitorBaseAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: TrigTauMonitorBaseAlgorithm.cxx:16
TauAnalysisTools::tauPt
double tauPt(const xAOD::TauJet &xTau)
return tau pt in GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:86
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
TrigTauMonitorSingleAlgorithm::m_monitoredHLTIdScores
Gaudi::Property< std::map< std::string, std::map< std::string, std::pair< std::string, std::string > > > > m_monitoredHLTIdScores
Definition: TrigTauMonitorSingleAlgorithm.h:31
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
TrigTauMonitorSingleAlgorithm::fillIDInputVars
void fillIDInputVars(const std::string &trigger, const std::vector< const xAOD::TauJet * > &tau_vec, const std::string &nProng, bool online) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:221
xAOD::TauJet_v3::nTracks
size_t nTracks(TauJetParameters::TauTrackFlag flag=TauJetParameters::TauTrackFlag::classifiedCharged) const
Definition: TauJet_v3.cxx:488
xAOD::passBits
passBits
Definition: TrigPassBits_v1.cxx:115
TrigTauMonitorBaseAlgorithm::getL1cTAUs
std::vector< std::pair< const xAOD::eFexTauRoI *, const xAOD::jFexTauRoI * > > getL1cTAUs(const EventContext &ctx, const std::string &l1_item) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:192
TrigTauMonitorBaseAlgorithm::classifyOnlineTaus
std::tuple< std::vector< const xAOD::TauJet * >, std::vector< const xAOD::TauJet * >, std::vector< const xAOD::TauJet * > > classifyOnlineTaus(const std::vector< const xAOD::TauJet * > &taus, const float threshold=0.0) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:304
xAOD::CaloCluster_v1::et
double et() const
Definition: CaloCluster_v1.h:859
xAOD::TauJetParameters::mEflowApprox
@ mEflowApprox
Definition: TauDefs.h:292
detail
Definition: extract_histogram_tag.cxx:14
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:260
xAOD::expectInnermostPixelLayerHit
@ expectInnermostPixelLayerHit
Do we expect a 0th-layer barrel hit for this track?
Definition: TrackingPrimitives.h:237
Phi
@ Phi
Definition: RPCdef.h:8
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
TrigTauMonitorBaseAlgorithm::getL1eTAUs
std::vector< const xAOD::eFexTauRoI * > getL1eTAUs(const EventContext &ctx, const std::string &l1_item) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:128
xAOD::TauJet_v3::ptJetSeed
double ptJetSeed() const
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
xAOD::TauJet_v3::ptDetectorAxis
double ptDetectorAxis() const
xAOD::TauJetParameters::ptRatioEflowApprox
@ ptRatioEflowApprox
Definition: TauDefs.h:293
TrigTauMonitorSingleAlgorithm::fillIDScores
void fillIDScores(const EventContext &ctx, const std::string &trigger, const std::vector< const xAOD::TauJet * > &tau_vec, const std::string &nProng, bool online) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:455
TrigTauMonitorSingleAlgorithm::TrigTauMonitorSingleAlgorithm
TrigTauMonitorSingleAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TrigTauMonitorSingleAlgorithm.cxx:10
TrigTauMonitorBaseAlgorithm::m_do_variable_plots
Gaudi::Property< bool > m_do_variable_plots
Definition: TrigTauMonitorBaseAlgorithm.h:47
TrigTauMonitorSingleAlgorithm::processEvent
virtual StatusCode processEvent(const EventContext &ctx) const override
Definition: TrigTauMonitorSingleAlgorithm.cxx:61
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
xAOD::TauJet_v3::clusters
std::vector< const IParticle * > clusters() const
Definition: TauJet_v3.cxx:545
TrigTauMonitorSingleAlgorithm::m_monitoredOfflineIdScores
Gaudi::Property< std::map< std::string, std::pair< std::string, std::string > > > m_monitoredOfflineIdScores
Definition: TrigTauMonitorSingleAlgorithm.h:35
TrigTauMonitorSingleAlgorithm::fillIDCluster
void fillIDCluster(const std::string &trigger, const std::vector< const xAOD::TauJet * > &tau_vec, bool online) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:361
xAOD::TauJetParameters::centFrac
@ centFrac
Get centrality fraction.
Definition: TauDefs.h:200
xAOD::TauJetParameters::dRmax
@ dRmax
Get maximal dR of tracks associated to calo-seeded tau.
Definition: TauDefs.h:226
xAOD::TauJet_v3::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
TrigTauMonitorSingleAlgorithm::m_monitoredOfflineIdDecorHandleKeys
std::map< std::string, std::pair< SG::ReadDecorHandleKey< xAOD::TauJetContainer >, SG::ReadDecorHandleKey< xAOD::TauJetContainer > > > m_monitoredOfflineIdDecorHandleKeys
Definition: TrigTauMonitorSingleAlgorithm.h:36
xAOD::TauJet_v3::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
TrigTauMonitorBaseAlgorithm::getOnlineTausAll
std::vector< const xAOD::TauJet * > getOnlineTausAll(const std::string &trigger, bool include_0P=true) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:56
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
TauGNNUtils::Variables::Cluster::SECOND_LAMBDA
bool SECOND_LAMBDA(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, float &out)
Definition: TauGNNUtils.cxx:717
xAOD::eFexTauRoI_v1
Class describing a LVL1 eFEX tau region of interest.
Definition: eFexTauRoI_v1.h:29
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
TrigTauMonitorBaseAlgorithm::getOnlineContainerKey
const SG::ReadHandleKey< xAOD::TauJetContainer > & getOnlineContainerKey(const std::string &sequence) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:236
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
xAOD::TauJetParameters::nChargedTracks
@ nChargedTracks
Definition: TauDefs.h:322
xAOD::TauJet_v3::track
const TauTrack * track(size_t i, TauJetParameters::TauTrackFlag flag=TauJetParameters::TauTrackFlag::classifiedCharged, int *container_index=0) const
Get the pointer to a given tauTrack associated with this tau /*container index needed by trackNonCons...
Definition: TauJet_v3.cxx:422
TrigTauMonitorSingleAlgorithm::m_offline_tau_id
Gaudi::Property< unsigned int > m_offline_tau_id
Definition: TrigTauMonitorSingleAlgorithm.h:25
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::TauJetParameters::etOverPtLeadTrk
@ etOverPtLeadTrk
Definition: TauDefs.h:158
hist_file_dump.f
f
Definition: hist_file_dump.py:140
xAOD::CaloCluster_v1::retrieveMoment
bool retrieveMoment(MomentType type, double &value) const
Retrieve individual moment.
Definition: CaloCluster_v1.cxx:662
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.
TauGNNUtils::Variables::Cluster::SECOND_R
bool SECOND_R(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, float &out)
Definition: TauGNNUtils.cxx:710
TrigTauMonitorSingleAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: TrigTauMonitorSingleAlgorithm.cxx:15
xAOD::TauJetParameters::massTrkSys
@ massTrkSys
Definition: TauDefs.h:161
xAOD::CaloCluster_v1::p4
virtual FourMom_t p4() const
The full 4-momentum of the particle.
Definition: CaloCluster_v1.cxx:465
xAOD::TauJet_v3::detail
bool detail(TauJetParameters::Detail detail, int &value) const
Get and set values of common details variables via enum.
Definition: TauJet_v3.cxx:264
TrigTauMonitorSingleAlgorithm::getRoIsVector
std::vector< TLorentzVector > getRoIsVector(const EventContext &ctx, const std::string &trigger) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:500
TauGNNUtils::Variables::Scalar::absipSigLeadTrk
bool absipSigLeadTrk(const xAOD::TauJet &tau, float &out)
Definition: TauGNNUtils.cxx:142
TrigTauMonitorSingleAlgorithm::m_requireOfflineTaus
Gaudi::Property< bool > m_requireOfflineTaus
Definition: TrigTauMonitorSingleAlgorithm.h:24
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
TrigTauMonitorBaseAlgorithm
Definition: TrigTauMonitorBaseAlgorithm.h:24
TrigTauMonitorBaseAlgorithm::m_do_efficiency_plots
Gaudi::Property< bool > m_do_efficiency_plots
Definition: TrigTauMonitorBaseAlgorithm.h:46
TrigTauMonitorBaseAlgorithm::classifyOfflineTaus
std::pair< std::vector< const xAOD::TauJet * >, std::vector< const xAOD::TauJet * > > classifyOfflineTaus(const std::vector< const xAOD::TauJet * > &taus, const float threshold=0.0, const TauID tau_id=TauID::None) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:321
TrigTauMonitorBaseAlgorithm::m_offlineTauJetKey
SG::ReadHandleKey< xAOD::TauJetContainer > m_offlineTauJetKey
Definition: TrigTauMonitorBaseAlgorithm.h:121
AthMonitorAlgorithm::lbAverageInteractionsPerCrossing
virtual float lbAverageInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the average mu, i.e.
Definition: AthMonitorAlgorithm.cxx:227
TrigTauMonitorSingleAlgorithm.h
xAOD::score
@ score
Definition: TrackingPrimitives.h:514
TrigTauMonitorSingleAlgorithm::m_doTotalEfficiency
Gaudi::Property< bool > m_doTotalEfficiency
Definition: TrigTauMonitorSingleAlgorithm.h:21
TrigTauInfo
Definition: TrigTauInfo.h:15
python.PyAthena.v
v
Definition: PyAthena.py:154
Prompt::Def::Pt
@ Pt
Definition: VarHolder.h:76
TrigTauMonitorBaseAlgorithm::classifyTausAll
std::vector< const xAOD::TauJet * > classifyTausAll(const std::vector< const xAOD::TauJet * > &taus, const float threshold=0.0, const TauID tau_id=TauID::None) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:276
TrigTauMonitorSingleAlgorithm::m_doOfflineTausDistributions
Gaudi::Property< bool > m_doOfflineTausDistributions
Definition: TrigTauMonitorSingleAlgorithm.h:28
TrigTauMonitorBaseAlgorithm::getL1jTAUs
std::vector< const xAOD::jFexTauRoI * > getL1jTAUs(const EventContext &ctx, const std::string &l1_item) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:160
xAOD::TauJet_v3::vertex
const Vertex * vertex() const
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:274
TrigTauMonitorBaseAlgorithm::matchObjects
bool matchObjects(const T1 *tau, const std::vector< const T2 * > &tau_vec, float threshold) const
Definition: TrigTauMonitorBaseAlgorithm.h:78
xAOD::TauTrack_v1
Definition: TauTrack_v1.h:27
xAOD::TauJet_v3::p4
virtual FourMom_t p4() const
The full 4-momentum of the particle.
Definition: TauJet_v3.cxx:96
TriggerTest.rois
rois
Definition: TriggerTest.py:23
xAOD::Vertex_v1::y
float y() const
Returns the y position.
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
TrigTauMonitorBaseAlgorithm::m_triggers
Gaudi::Property< std::vector< std::string > > m_triggers
Definition: TrigTauMonitorBaseAlgorithm.h:38
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
TrigTauMonitorSingleAlgorithm::fillIDTrack
void fillIDTrack(const std::string &trigger, const std::vector< const xAOD::TauJet * > &tau_vec, bool online) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:290
ReadDecorHandle.h
Handle class for reading a decoration on an object.
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:267
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
TrigTauMonitorBaseAlgorithm::getTrigInfo
const TrigTauInfo & getTrigInfo(const std::string &trigger) const
Definition: TrigTauMonitorBaseAlgorithm.h:51
xAOD::TauJetParameters::SumPtTrkFrac
@ SumPtTrkFrac
Definition: TauDefs.h:289
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
TrigTauMonitorSingleAlgorithm::fillBasicVars
void fillBasicVars(const EventContext &ctx, const std::string &trigger, const std::vector< const xAOD::TauJet * > &tau_vec, const std::string &nProng, bool online) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:413
SG::ReadDecorHandleKey
Property holding a SG store/key/clid/attr name from which a ReadDecorHandle is made.
Definition: StoreGate/StoreGate/ReadDecorHandleKey.h:85
xAOD::TauJet_v3::nTracksIsolation
size_t nTracksIsolation() const
Definition: TauJet_v3.cxx:498
TauGNNUtils::Variables::Scalar::ptDetectorAxis
bool ptDetectorAxis(const xAOD::TauJet &tau, float &out)
Definition: TauGNNUtils.cxx:216
TrigTauMonitorSingleAlgorithm::m_monitoredHLTIdDecorHandleKeys
std::map< std::string, std::map< std::string, std::pair< SG::ReadDecorHandleKey< xAOD::TauJetContainer >, SG::ReadDecorHandleKey< xAOD::TauJetContainer > > > > m_monitoredHLTIdDecorHandleKeys
Definition: TrigTauMonitorSingleAlgorithm.h:32
SG::ReadDecorHandle::isAvailable
bool isAvailable()
Test to see if this variable exists in the store, for the referenced object.
TauGNNUtils::Variables::Cluster::CENTER_LAMBDA
bool CENTER_LAMBDA(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, float &out)
Definition: TauGNNUtils.cxx:724
python.ParticleTypeUtil.info
def info
Definition: ParticleTypeUtil.py:87
TrigTauMonitorSingleAlgorithm::fillHLTEfficiencies
void fillHLTEfficiencies(const EventContext &ctx, const std::string &trigger, const bool l1_accept_flag, const std::vector< const xAOD::TauJet * > &offline_tau_vec, const std::vector< const xAOD::TauJet * > &online_tau_vec, const std::string &nProng) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:152
xAOD::TauJet_v3::allTracks
std::vector< const TauTrack * > allTracks() const
Get the v<const pointer> to all tracks associated with this tau, regardless of classification.
Definition: TauJet_v3.cxx:482
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
Eta
@ Eta
Definition: RPCdef.h:8
TrigTauMonitorBaseAlgorithm::getOfflineTausAll
std::vector< const xAOD::TauJet * > getOfflineTausAll(const EventContext &ctx, const float threshold=20.0) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:86
xAOD::TauJetParameters::EMPOverTrkSysP
@ EMPOverTrkSysP
Definition: TauDefs.h:279
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:238
python.SystemOfUnits.m
float m
Definition: SystemOfUnits.py:106
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Tue Sep 30 2025 21:21:10 for ATLAS Offline Software by   doxygen 1.8.18