ATLAS Offline Software
TrigTauMonitorSingleAlgorithm.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "TrigTauMonitorSingleAlgorithm.h"
6 
7 
8 TrigTauMonitorSingleAlgorithm::TrigTauMonitorSingleAlgorithm(const std::string& name, ISvcLocator* pSvcLocator)
9  : TrigTauMonitorBaseAlgorithm(name, pSvcLocator)
10 {}
11 
12 
13 StatusCode TrigTauMonitorSingleAlgorithm::processEvent(const EventContext& ctx) const
14 {
15  constexpr float threshold_offset = 10.0;
16 
17  // Offline taus
18  auto offline_taus_all = getOfflineTausAll(ctx, 0.0);
19 
20  if(m_requireOfflineTaus && offline_taus_all.empty()) return StatusCode::SUCCESS;
21 
22  for(const std::string& trigger : m_triggers) {
23  const TrigTauInfo& info = getTrigInfo(trigger);
24 
25  if(!info.isHLTSingleTau()) {
26  ATH_MSG_WARNING("Chain \"" << trigger << "\" is not a single tau trigger. Skipping...");
27  continue;
28  }
29 
30  const auto passBits = m_trigDecTool->isPassedBits(trigger);
31  const bool l1_accept_flag = passBits & TrigDefs::L1_isPassedAfterVeto;
32  const bool hlt_not_prescaled_flag = (passBits & TrigDefs::EF_prescaled) == 0;
33 
34  // Filter offline taus
35  auto offline_taus = classifyOfflineTaus(offline_taus_all, info.getHLTTauThreshold() - threshold_offset);
36  std::vector<const xAOD::TauJet*> offline_taus_1p = offline_taus.first;
37  std::vector<const xAOD::TauJet*> offline_taus_3p = offline_taus.second;
38 
39  // Online taus
40  std::vector<const xAOD::TauJet*> hlt_taus_all = getOnlineTausAll(trigger, true);
41  auto hlt_taus = classifyOnlineTaus(hlt_taus_all);
42  std::vector<const xAOD::TauJet*> hlt_taus_0p = std::get<0>(hlt_taus);
43  std::vector<const xAOD::TauJet*> hlt_taus_1p = std::get<1>(hlt_taus);
44  std::vector<const xAOD::TauJet*> hlt_taus_mp = std::get<2>(hlt_taus);
45 
46  if(m_do_variable_plots) {
47  // Offline variables:
48  if(m_doOfflineTausDistributions && !offline_taus_1p.empty()) {
49  fillBasicVars(ctx, trigger, offline_taus_1p, "1P", false);
50  fillRNNInputVars(trigger, offline_taus_1p, "1P", false);
51  fillRNNTrack(trigger, offline_taus_1p, false);
52  fillRNNCluster(trigger, offline_taus_1p, false);
53  }
54  if(m_doOfflineTausDistributions && !offline_taus_3p.empty()) {
55  fillBasicVars(ctx, trigger, offline_taus_3p, "3P", false);
56  fillRNNInputVars(trigger, offline_taus_3p, "3P", false);
57  fillRNNTrack(trigger, offline_taus_3p, false);
58  fillRNNCluster(trigger, offline_taus_3p, false);
59  }
60 
61  // Fill information for online 0 prong taus
62  if(!hlt_taus_0p.empty()) {
63  fillBasicVars(ctx, trigger, hlt_taus_0p, "0P", true);
64  fillRNNInputVars(trigger, hlt_taus_0p, "0P", true);
65  fillRNNTrack(trigger, hlt_taus_0p, true);
66  fillRNNCluster(trigger, hlt_taus_0p, true);
67  }
68 
69  // Fill information for online 1 prong taus
70  if(!hlt_taus_1p.empty()) {
71  fillBasicVars(ctx, trigger, hlt_taus_1p, "1P", true);
72  fillRNNInputVars(trigger, hlt_taus_1p, "1P", true);
73  fillRNNTrack(trigger, hlt_taus_1p, true);
74  fillRNNCluster(trigger, hlt_taus_1p, true);
75  }
76 
77  // Fill information for online multiprong prong taus
78  if(!hlt_taus_mp.empty()) {
79  fillBasicVars(ctx, trigger, hlt_taus_mp, "MP", true);
80  fillRNNInputVars(trigger, hlt_taus_mp, "MP", true);
81  fillRNNTrack(trigger, hlt_taus_mp, true);
82  fillRNNCluster(trigger, hlt_taus_mp, true);
83  }
84  }
85 
86  if(m_do_efficiency_plots && hlt_not_prescaled_flag) {
87  fillHLTEfficiencies(ctx, trigger, l1_accept_flag, offline_taus_1p, hlt_taus_all, "1P");
88  fillHLTEfficiencies(ctx, trigger, l1_accept_flag, offline_taus_3p, hlt_taus_all, "3P");
89  }
90  }
91 
92  return StatusCode::SUCCESS;
93 }
94 
95 
96 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
97 {
98  ATH_MSG_DEBUG("Fill HLT " << nProng << " efficiencies: " << trigger);
99 
100  const TrigTauInfo& info = getTrigInfo(trigger);
101 
102  // Efficiency for single leg tau triggers:
103  // denominator = offline tau + matching with L1 object with dR(offline tau,L1 item) < 0.3
104  // numerator = denominator + hlt fires + matching with HLT tau with dR(offline tau, HLT tau) < 0.2
105 
106  auto monGroup = getGroup(trigger+"_HLT_Efficiency_"+nProng);
107 
108  auto tauPt = Monitored::Scalar<float>("tauPt", 0.0);
109  auto tauEta = Monitored::Scalar<float>("tauEta", 0.0);
110  auto tauPhi = Monitored::Scalar<float>("tauPhi", 0.0);
111  auto averageMu = Monitored::Scalar<float>("averageMu", 0.0);
112  auto HLT_match = Monitored::Scalar<bool>("HLT_pass", false);
113  auto HLT_match_highPt = Monitored::Scalar<bool>("HLT_pass_highPt", false);
114  auto Total_match = Monitored::Scalar<bool>("Total_pass", false);
115  auto Total_match_highPt = Monitored::Scalar<bool>("Total_pass_highPt", false);
116 
117  bool hlt_fires = m_trigDecTool->isPassed(trigger, TrigDefs::Physics | TrigDefs::allowResurrectedDecision);
118 
119  std::vector<TLorentzVector> rois = getRoIsVector(ctx, trigger);
120  for(const auto *offline_tau : offline_tau_vec) {
121  bool L1_match = false;
122 
123  // Check the matching offline tau with L1 item -> depending on the L1 type (legacy, phase-1 eTAU, jTAU, cTAU)
124  // All L1 RoIs have a core size of 3x3 TTs -> 0.3 x 0.3
125  for(const TLorentzVector& roi : rois) {
126  L1_match = offline_tau->p4().DeltaR(roi) <= 0.3;
127  if(L1_match) break;
128  }
129 
130  tauPt = offline_tau->pt()/Gaudi::Units::GeV;
131  tauEta = offline_tau->eta();
132  tauPhi = offline_tau->phi();
133  averageMu = lbAverageInteractionsPerCrossing(ctx);
134 
135  bool is_highPt = tauPt > info.getHLTTauThreshold() + 20.0;
136 
137  // HLT matching: dR matching + HLT fires
138  HLT_match = matchObjects(offline_tau, online_tau_vec, 0.2) && hlt_fires;
139 
140  // Total efficiency (without L1 matching)
141  if(m_doTotalEfficiency) {
142  Total_match = static_cast<bool>(HLT_match);
143  fill(monGroup, tauPt, tauEta, tauPhi, Total_match);
144 
145  if(is_highPt) {
146  Total_match_highPt = static_cast<bool>(HLT_match);
147  fill(monGroup, tauEta, tauPhi, Total_match_highPt);
148  }
149  }
150 
151  if(!L1_match || !l1_accept_flag) continue; // Skip this offline tau since not matched with L1 item
152 
153  fill(monGroup, tauPt, tauEta, tauPhi, averageMu, HLT_match);
154 
155  if(is_highPt) {
156  HLT_match_highPt = static_cast<bool>(HLT_match);
157  fill(monGroup, tauEta, tauPhi, HLT_match_highPt);
158  }
159  }
160 
161  ATH_MSG_DEBUG("After fill HLT efficiencies: " << trigger);
162 }
163 
164 
165 void TrigTauMonitorSingleAlgorithm::fillRNNInputVars(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec,const std::string& nProng, bool online) const
166 {
167  ATH_MSG_DEBUG("Fill RNN input variables: " << trigger);
168 
169  auto monGroup = getGroup(trigger+"_RNN_"+(online ? "HLT" : "Offline")+"_InputScalar_"+nProng);
170 
171  auto centFrac = Monitored::Collection("centFrac", tau_vec, [](const xAOD::TauJet* tau){
172  float detail = -999;
173  if(tau->detail(xAOD::TauJetParameters::centFrac, detail)) detail = std::min(detail, 1.0f);
174  return detail;
175  });
176  auto etOverPtLeadTrk = Monitored::Collection("etOverPtLeadTrk", tau_vec, [](const xAOD::TauJet* tau){
177  float detail = -999;
178  if(tau->detail(xAOD::TauJetParameters::etOverPtLeadTrk, detail)) detail = std::log10(std::max(detail, 0.1f));
179  return detail;
180  });
181  auto dRmax = Monitored::Collection("dRmax", tau_vec, [](const xAOD::TauJet* tau){
182  float detail = -999;
183  tau->detail(xAOD::TauJetParameters::dRmax, detail);
184  return detail;
185  });
186  auto absipSigLeadTrk = Monitored::Collection("absipSigLeadTrk", tau_vec, [](const xAOD::TauJet* tau){
187  float detail = (tau->nTracks()>0) ? std::abs(tau->track(0)->d0SigTJVA()) : 0;
188  detail = std::min(std::abs(detail), 30.0f);
189  return detail;
190  });
191  auto sumPtTrkFrac = Monitored::Collection("sumPtTrkFrac", tau_vec, [](const xAOD::TauJet* tau){
192  float detail = -999;
193  tau->detail(xAOD::TauJetParameters::SumPtTrkFrac, detail);
194  return detail;
195  });
196  auto emPOverTrkSysP = Monitored::Collection("emPOverTrkSysP", tau_vec, [](const xAOD::TauJet* tau){
197  float detail = -999;
198  if(tau->detail(xAOD::TauJetParameters::EMPOverTrkSysP, detail)) detail = std::log10(std::max(detail, 1e-3f));
199  return detail;
200  });
201  auto ptRatioEflowApprox = Monitored::Collection("ptRatioEflowApprox", tau_vec, [](const xAOD::TauJet* tau){
202  float detail = -999;
203  if(tau->detail(xAOD::TauJetParameters::ptRatioEflowApprox, detail)) detail = std::min(detail, 4.0f);
204  return detail;
205  });
206  auto mEflowApprox = Monitored::Collection("mEflowApprox", tau_vec, [](const xAOD::TauJet* tau){
207  float detail = -999;
208  if(tau->detail(xAOD::TauJetParameters::mEflowApprox, detail)) detail = std::log10(std::max(detail, 140.0f));
209  return detail;
210  });
211  auto ptDetectorAxis = Monitored::Collection("ptDetectorAxis", tau_vec, [](const xAOD::TauJet* tau){
212  float detail = -999;
213  if( tau->ptDetectorAxis() > 0) detail = std::log10(std::min(tau->ptDetectorAxis()/Gaudi::Units::GeV, 100.0));
214  return detail;
215  });
216  auto massTrkSys = Monitored::Collection("massTrkSys", tau_vec, [&nProng](const xAOD::TauJet* tau){
217  float detail = -999;
218  if( tau->detail(xAOD::TauJetParameters::massTrkSys, detail) && (nProng.find("MP") != std::string::npos || nProng.find("3P") != std::string::npos)) {
219  detail = std::log10(std::max(detail, 140.0f));
220  }
221  return detail;});
222  auto trFlightPathSig = Monitored::Collection("trFlightPathSig", tau_vec, [&nProng](const xAOD::TauJet* tau){
223  float detail = -999;
224  if(nProng.find("MP") != std::string::npos || nProng.find("3P") != std::string::npos) tau->detail(xAOD::TauJetParameters::trFlightPathSig, detail);
225  return detail;
226  });
227 
228  fill(monGroup, centFrac, etOverPtLeadTrk, dRmax, absipSigLeadTrk, sumPtTrkFrac, emPOverTrkSysP, ptRatioEflowApprox, mEflowApprox, ptDetectorAxis, massTrkSys, trFlightPathSig);
229 
230  ATH_MSG_DEBUG("After fill RNN input variables: " << trigger);
231 }
232 
233 
234 void TrigTauMonitorSingleAlgorithm::fillRNNTrack(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const
235 {
236  ATH_MSG_DEBUG("Fill RNN input Track: " << trigger);
237 
238  auto monGroup = getGroup(trigger+"_RNN_"+(online ? "HLT" : "Offline")+"_InputTrack");
239 
240  auto track_pt_jetseed_log = Monitored::Collection("track_pt_jetseed_log", tau_vec, [](const xAOD::TauJet* tau){ return std::log10(tau->ptJetSeed()); });
241  fill(monGroup, track_pt_jetseed_log);
242 
243  for(const auto *tau : tau_vec) {
244  // Don't call ->allTracks() unless the element links are valid
245  const SG::AuxElement::ConstAccessor< std::vector<ElementLink<xAOD::TauTrackContainer>> > tauTrackAcc("tauTrackLinks");
246  bool linksValid = true;
247  for(const ElementLink<xAOD::TauTrackContainer>& trackEL : tauTrackAcc(*tau)) {
248  if(!trackEL.isValid()) {
249  linksValid = false;
250  break;
251  }
252  }
253 
254  if(!linksValid) {
255  ATH_MSG_WARNING("Invalid track element links from TauJet in " << trigger);
256  continue;
257  }
258 
259  auto tracks = tau->allTracks();
260  std::sort(tracks.begin(), tracks.end(), [](const xAOD::TauTrack* lhs, const xAOD::TauTrack* rhs){ return lhs->pt() > rhs->pt(); });
261 
262  auto n_track = Monitored::Scalar<int>("n_track",0);
263  n_track = tracks.size();
264 
265  auto track_pt_log = Monitored::Collection("track_pt_log", tracks, [](const xAOD::TauTrack *track){ return std::log10(track->pt()); });
266  auto track_eta = Monitored::Collection("track_eta", tracks, [](const xAOD::TauTrack *track){ return track->eta(); });
267  auto track_phi = Monitored::Collection("track_phi", tracks, [](const xAOD::TauTrack *track){ return track->phi(); });
268  auto track_dEta = Monitored::Collection("track_dEta", tracks, [&tau](const xAOD::TauTrack *track){ return track->eta() - tau->eta(); });
269  auto track_dPhi = Monitored::Collection("track_dPhi", tracks, [&tau](const xAOD::TauTrack *track){ return track->p4().DeltaPhi(tau->p4()); });
270  auto track_z0sinthetaTJVA_abs_log = Monitored::Collection("track_z0sinthetaTJVA_abs_log", tracks, [](const xAOD::TauTrack *track){return track->z0sinthetaTJVA(); });
271  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); });
272  auto track_nIBLHitsAndExp = Monitored::Collection("track_nIBLHitsAndExp", tracks, [](const xAOD::TauTrack *track){
273  uint8_t inner_pixel_hits, inner_pixel_exp;
274  const auto success1_innerPixel_hits = track->track()->summaryValue(inner_pixel_hits, xAOD::numberOfInnermostPixelLayerHits);
275  const auto success2_innerPixel_exp = track->track()->summaryValue(inner_pixel_exp, xAOD::expectInnermostPixelLayerHit);
276  float detail = -999;
277  if(success1_innerPixel_hits && success2_innerPixel_exp) { detail = inner_pixel_exp ? inner_pixel_hits : 1.; };
278  return detail;
279  });
280  auto track_nPixelHitsPlusDeadSensors = Monitored::Collection("track_nPixelHitsPlusDeadSensors", tracks, [](const xAOD::TauTrack *track){
281  uint8_t pixel_hits, pixel_dead;
282  const auto success1_pixel_hits = track->track()->summaryValue(pixel_hits, xAOD::numberOfPixelHits);
283  const auto success2_pixel_dead = track->track()->summaryValue(pixel_dead, xAOD::numberOfPixelDeadSensors);
284  float detail = -999;
285  if(success1_pixel_hits && success2_pixel_dead) { detail = pixel_hits + pixel_dead; };
286  return detail;
287  });
288  auto track_nSCTHitsPlusDeadSensors = Monitored::Collection("track_nSCTHitsPlusDeadSensors", tracks, [](const xAOD::TauTrack *track){
289  uint8_t sct_hits, sct_dead;
290  const auto success1_sct_hits = track->track()->summaryValue(sct_hits, xAOD::numberOfSCTHits);
291  const auto success2_sct_dead = track->track()->summaryValue(sct_dead, xAOD::numberOfSCTDeadSensors);
292  float detail = -999;
293  if(success1_sct_hits && success2_sct_dead) { detail = sct_hits + sct_dead; };
294  return detail;
295  });
296 
297  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);
298  }
299 
300  ATH_MSG_DEBUG("After fill RNN input Track: " << trigger);
301 }
302 
303 
304 void TrigTauMonitorSingleAlgorithm::fillRNNCluster(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const
305 {
306  ATH_MSG_DEBUG("Fill RNN input Cluster: " << trigger << " for online/offline " << online);
307 
308  auto monGroup = getGroup(trigger+"_RNN_"+(online ? "HLT" : "Offline")+"_InputCluster");
309 
310  for(const auto *tau : tau_vec){
311  auto cluster_pt_jetseed_log = Monitored::Collection("cluster_pt_jetseed_log", tau_vec, [](const xAOD::TauJet* tau){ return std::log10(tau->ptJetSeed()); });
312 
313  std::vector<const xAOD::CaloCluster*> clusters;
314  for(const xAOD::IParticle* particle : tau->clusters()) {
315  const xAOD::CaloCluster* cluster = static_cast<const xAOD::CaloCluster*>(particle);
316  clusters.push_back(cluster);
317  }
318  std::sort(clusters.begin(), clusters.end(), [](const xAOD::CaloCluster *lhs, const xAOD::CaloCluster *rhs){ return lhs->et() > rhs->et(); });
319 
320  auto n_cluster = Monitored::Scalar<int>("n_cluster", 0);
321  n_cluster = clusters.size();
322 
323  auto cluster_et_log = Monitored::Collection("cluster_et_log",clusters, [](const xAOD::CaloCluster *cluster){ return std::log10( cluster->et()); });
324  auto cluster_eta = Monitored::Collection("cluster_eta", clusters, [](const xAOD::CaloCluster *cluster){ return cluster->eta(); });
325  auto cluster_phi = Monitored::Collection("cluster_phi", clusters, [](const xAOD::CaloCluster *cluster){ return cluster->phi(); });
326  auto cluster_dEta = Monitored::Collection("cluster_dEta", clusters, [&tau](const xAOD::CaloCluster *cluster){ return cluster->eta() - tau->eta(); });
327  auto cluster_dPhi = Monitored::Collection("cluster_dPhi", clusters, [&tau](const xAOD::CaloCluster *cluster){ return cluster->p4().DeltaPhi(tau->p4()); });
328  auto cluster_SECOND_R_log10 = Monitored::Collection("cluster_SECOND_R_log10", clusters, [](const xAOD::CaloCluster *cluster){
329  double detail = -999;
330  const auto success_SECOND_R = cluster->retrieveMoment(xAOD::CaloCluster::MomentType::SECOND_R,detail);
331  if(success_SECOND_R) detail = std::log10(detail + 0.1);
332  return detail;
333  });
334 
335  auto cluster_SECOND_LAMBDA_log10 = Monitored::Collection("cluster_SECOND_LAMBDA_log10", clusters, [](const xAOD::CaloCluster *cluster){
336  double detail = -999;
337  const auto success_SECOND_LAMBDA = cluster->retrieveMoment(xAOD::CaloCluster::MomentType::SECOND_LAMBDA, detail);
338  if(success_SECOND_LAMBDA) detail = std::log10(detail + 0.1);
339  return detail;
340  });
341 
342  auto cluster_CENTER_LAMBDA_log10 = Monitored::Collection("cluster_CENTER_LAMBDA_log10", clusters, [](const xAOD::CaloCluster *cluster){
343  double detail = -999;
344  const auto success_CENTER_LAMBDA = cluster->retrieveMoment(xAOD::CaloCluster::MomentType::CENTER_LAMBDA, detail);
345  if(success_CENTER_LAMBDA) detail = std::log10(detail + 1e-6);
346  return detail;
347  });
348 
349  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);
350  }
351 
352  ATH_MSG_DEBUG("After fill RNN input Cluster: " << trigger);
353 }
354 
355 
356 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
357 {
358  ATH_MSG_DEBUG("Fill Basic Variables: " << trigger);
359 
360  auto monGroup = getGroup(trigger+"_"+(online ? "HLT" : "Offline")+"_basicVars_"+nProng);
361 
362  auto Pt = Monitored::Collection("Pt", tau_vec, [](const xAOD::TauJet* tau){ return tau->pt()/Gaudi::Units::GeV; });
363  auto Eta = Monitored::Collection("Eta", tau_vec, [](const xAOD::TauJet* tau){ return tau->eta(); });
364 
365  auto Phi = Monitored::Collection("Phi", tau_vec, [](const xAOD::TauJet* tau){ return tau->phi(); });
366  auto nTrack = Monitored::Collection("nTrack", tau_vec, [](const xAOD::TauJet* tau){
367  int nTrack = -1;
368  tau->detail(xAOD::TauJetParameters::nChargedTracks, nTrack);
369  return nTrack;
370  });
371  auto nWideTrack = Monitored::Collection("nWideTrack", tau_vec, [](const xAOD::TauJet* tau){ return tau->nTracksIsolation(); });
372 
373  auto RNNScore = Monitored::Collection("RNNScore", tau_vec, [](const xAOD::TauJet* tau){ return tau->discriminant(xAOD::TauJetParameters::RNNJetScore); });
374  auto RNNScoreSigTrans = Monitored::Collection("RNNScoreSigTrans", tau_vec, [](const xAOD::TauJet* tau){ return tau->discriminant(xAOD::TauJetParameters::RNNJetScoreSigTrans); });
375 
376  auto averageMu = Monitored::Scalar<float>("averageMu", 0.0);
377  averageMu = lbAverageInteractionsPerCrossing(ctx);
378 
379  auto TauVertexX = Monitored::Collection("TauVertexX", tau_vec, [](const xAOD::TauJet* tau){
380  double vtx = -999;
381  if(tau->vertex() != nullptr) vtx = tau->vertex()->x();
382  return vtx;
383  });
384 
385  auto TauVertexY = Monitored::Collection("TauVertexY", tau_vec, [](const xAOD::TauJet* tau){
386  double vty = -999;
387  if(tau->vertex() != nullptr) vty = tau->vertex()->y();
388  return vty;
389  });
390 
391  auto TauVertexZ = Monitored::Collection("TauVertexZ", tau_vec, [](const xAOD::TauJet* tau){
392  double vtz = -999;
393  if(tau->vertex() != nullptr) vtz = tau->vertex()->z();
394  return vtz;
395  });
396 
397  fill(monGroup, Pt, Eta, Phi, nTrack, nWideTrack, RNNScore, RNNScoreSigTrans, averageMu, TauVertexX, TauVertexY, TauVertexZ);
398 
399  ATH_MSG_DEBUG("After fill Basic variables: " << trigger);
400 }
401 
402 
403 std::vector<TLorentzVector> TrigTauMonitorSingleAlgorithm::getRoIsVector(const EventContext& ctx, const std::string& trigger) const
404 {
405  std::vector<TLorentzVector> ret;
406 
407  const TrigTauInfo& info = getTrigInfo(trigger);
408 
409  TLorentzVector v;
410  if(info.getL1TauType() == "eTAU") {
411  for(const xAOD::eFexTauRoI* roi : getL1eTAUs(ctx, info.getL1TauItem())) {
412  v.SetPtEtaPhiM(roi->et(), roi->eta(), roi->phi(), 0);
413  ret.push_back(v);
414  }
415  } else if(info.getL1TauType() == "jTAU") {
416  for(const xAOD::jFexTauRoI* roi : getL1jTAUs(ctx, info.getL1TauItem())) {
417  v.SetPtEtaPhiM(roi->et(), roi->eta(), roi->phi(), 0);
418  ret.push_back(v);
419  }
420  } else if(info.getL1TauType() == "cTAU") {
421  for(const auto& [eTau_roi, jTau_roi] : getL1cTAUs(ctx, info.getL1TauItem())) {
422  v.SetPtEtaPhiM(eTau_roi->et(), eTau_roi->eta(), eTau_roi->phi(), 0);
423  ret.push_back(v);
424  }
425  } else { // Legacy
426  for(const xAOD::EmTauRoI* roi : getL1LegacyTAUs(ctx, info.getL1TauItem())) {
427  v.SetPtEtaPhiM(roi->eT(), roi->eta(), roi->phi(), 0);
428  ret.push_back(v);
429  }
430  }
431 
432  return ret;
433 }
grepfile.info
info
Definition: grepfile.py:38
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
xAOD::jFexTauRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexTauRoI_v1.h:22
xAOD::Vertex_v1::x
float x() const
Returns the x position.
python.TIDAMonTool.monGroup
def monGroup(analysis_chain)
Definition: TIDAMonTool.py:295
TrigTauMonitorSingleAlgorithm::fillRNNInputVars
void fillRNNInputVars(const std::string &trigger, const std::vector< const xAOD::TauJet * > &tau_vec, const std::string &nProng, bool online) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:165
xAOD::TauJetParameters::RNNJetScoreSigTrans
@ RNNJetScoreSigTrans
RNN score which is signal transformed/flattened.
Definition: TauDefs.h:92
TauGNNUtils::Variables::Cluster::CENTER_LAMBDA
bool CENTER_LAMBDA(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:826
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:76
max
#define max(a, b)
Definition: cfImp.cxx:41
TauAnalysisTools::tauEta
double tauEta(const xAOD::TauJet &xTau)
return tau eta
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:99
xAOD::TauJetParameters::trFlightPathSig
@ trFlightPathSig
Definition: TauDefs.h:163
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
xAOD::TauJet_v3::discriminant
double discriminant(TauJetParameters::TauID discID) const
Get value of discriminant.
Definition: TauJet_v3.cxx:253
TauGNNUtils::Variables::absipSigLeadTrk
bool absipSigLeadTrk(const xAOD::TauJet &tau, double &out)
Definition: TauGNNUtils.cxx:267
xAOD::TauTrack_v1::d0SigTJVA
float d0SigTJVA() const
Definition: TauTrack_v1.cxx:129
xAOD::TauJet_v3::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
TauAnalysisTools::tauPt
double tauPt(const xAOD::TauJet &xTau)
return tau pt in GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:85
xAOD::TauJet_v3::nTracks
size_t nTracks(TauJetParameters::TauTrackFlag flag=TauJetParameters::TauTrackFlag::classifiedCharged) const
Definition: TauJet_v3.cxx:526
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:189
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:317
xAOD::CaloCluster_v1::et
double et() const
Definition: CaloCluster_v1.h:856
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:259
xAOD::expectInnermostPixelLayerHit
@ expectInnermostPixelLayerHit
Do we expect a 0th-layer barrel hit for this track?
Definition: TrackingPrimitives.h:236
Phi
@ Phi
Definition: RPCdef.h:8
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:54
TrigTauMonitorBaseAlgorithm::getL1eTAUs
std::vector< const xAOD::eFexTauRoI * > getL1eTAUs(const EventContext &ctx, const std::string &l1_item) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:125
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:40
xAOD::TauJet_v3::ptDetectorAxis
double ptDetectorAxis() const
xAOD::TauJetParameters::ptRatioEflowApprox
@ ptRatioEflowApprox
Definition: TauDefs.h:293
TrigTauMonitorSingleAlgorithm::TrigTauMonitorSingleAlgorithm
TrigTauMonitorSingleAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TrigTauMonitorSingleAlgorithm.cxx:8
TrigTauMonitorBaseAlgorithm::m_do_variable_plots
Gaudi::Property< bool > m_do_variable_plots
Definition: TrigTauMonitorBaseAlgorithm.h:41
TrigTauMonitorSingleAlgorithm::processEvent
virtual StatusCode processEvent(const EventContext &ctx) const override
Definition: TrigTauMonitorSingleAlgorithm.cxx:13
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:585
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
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:55
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
TrigTauMonitorSingleAlgorithm::fillRNNTrack
void fillRNNTrack(const std::string &trigger, const std::vector< const xAOD::TauJet * > &tau_vec, bool online) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:234
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
Definition: TrigTauMonitorBaseAlgorithm.cxx:336
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
xAOD::EmTauRoI_v2
Class describing a LVL1 em/tau region of interest.
Definition: EmTauRoI_v2.h:35
ret
T ret(T t)
Definition: rootspy.cxx:260
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
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:450
xAOD::TauJetParameters::etOverPtLeadTrk
@ etOverPtLeadTrk
Definition: TauDefs.h:158
xAOD::CaloCluster_v1::retrieveMoment
bool retrieveMoment(MomentType type, double &value) const
Retrieve individual moment.
Definition: CaloCluster_v1.cxx:738
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.
TrigTauMonitorSingleAlgorithm::fillRNNCluster
void fillRNNCluster(const std::string &trigger, const std::vector< const xAOD::TauJet * > &tau_vec, bool online) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:304
TauGNNUtils::Variables::Cluster::SECOND_LAMBDA
bool SECOND_LAMBDA(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:821
xAOD::TauJetParameters::massTrkSys
@ massTrkSys
Definition: TauDefs.h:161
min
#define min(a, b)
Definition: cfImp.cxx:40
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
Set veto flag.
Definition: TauJet_v3.cxx:292
TrigTauMonitorSingleAlgorithm::getRoIsVector
std::vector< TLorentzVector > getRoIsVector(const EventContext &ctx, const std::string &trigger) const
Definition: TrigTauMonitorSingleAlgorithm.cxx:403
TrigTauMonitorSingleAlgorithm::m_requireOfflineTaus
Gaudi::Property< bool > m_requireOfflineTaus
Definition: TrigTauMonitorSingleAlgorithm.h:21
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
TrigTauMonitorBaseAlgorithm
Definition: TrigTauMonitorBaseAlgorithm.h:24
TauGNNUtils::Variables::Cluster::SECOND_R
bool SECOND_R(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:816
TrigTauMonitorBaseAlgorithm::m_do_efficiency_plots
Gaudi::Property< bool > m_do_efficiency_plots
Definition: TrigTauMonitorBaseAlgorithm.h:40
AthMonitorAlgorithm::lbAverageInteractionsPerCrossing
virtual float lbAverageInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the average mu, i.e.
Definition: AthMonitorAlgorithm.cxx:222
TrigTauMonitorSingleAlgorithm.h
xAOD::TauJetParameters::RNNJetScore
@ RNNJetScore
RNN score for Jet rejection (not transformed)
Definition: TauDefs.h:90
TrigTauMonitorSingleAlgorithm::m_doTotalEfficiency
Gaudi::Property< bool > m_doTotalEfficiency
Definition: TrigTauMonitorSingleAlgorithm.h:18
TrigTauInfo
Definition: TrigTauInfo.h:15
python.PyAthena.v
v
Definition: PyAthena.py:157
Prompt::Def::Pt
@ Pt
Definition: VarHolder.h:76
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
TrigTauMonitorSingleAlgorithm::m_doOfflineTausDistributions
Gaudi::Property< bool > m_doOfflineTausDistributions
Definition: TrigTauMonitorSingleAlgorithm.h:24
TrigTauMonitorBaseAlgorithm::getL1jTAUs
std::vector< const xAOD::jFexTauRoI * > getL1jTAUs(const EventContext &ctx, const std::string &l1_item) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:157
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:273
TrigTauMonitorBaseAlgorithm::matchObjects
bool matchObjects(const T1 *tau, const std::vector< const T2 * > &tau_vec, float threshold) const
Definition: TrigTauMonitorBaseAlgorithm.h:73
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:97
TriggerTest.rois
rois
Definition: TriggerTest.py:23
xAOD::Vertex_v1::y
float y() const
Returns the y position.
TrigTauMonitorBaseAlgorithm::getL1LegacyTAUs
std::vector< const xAOD::EmTauRoI * > getL1LegacyTAUs(const EventContext &ctx, const std::string &l1_item) const
Definition: TrigTauMonitorBaseAlgorithm.cxx:233
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
TrigTauMonitorBaseAlgorithm::m_triggers
Gaudi::Property< std::vector< std::string > > m_triggers
Definition: TrigTauMonitorBaseAlgorithm.h:32
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:266
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
TrigTauMonitorBaseAlgorithm::getTrigInfo
const TrigTauInfo & getTrigInfo(const std::string &trigger) const
Definition: TrigTauMonitorBaseAlgorithm.h:45
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:356
TauGNNUtils::Variables::ptDetectorAxis
bool ptDetectorAxis(const xAOD::TauJet &tau, double &out)
Definition: TauGNNUtils.cxx:341
xAOD::TauJet_v3::nTracksIsolation
size_t nTracksIsolation() const
Definition: TauJet_v3.cxx:536
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
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:96
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:514
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:83
xAOD::TauJetParameters::EMPOverTrkSysP
@ EMPOverTrkSysP
Definition: TauDefs.h:279
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:237
PhysDESDM_Quirks.trigger
trigger
Definition: PhysDESDM_Quirks.py:27
Generated on Fri Jul 5 2024 21:31:13 for ATLAS Offline Software by   doxygen 1.8.18