ATLAS Offline Software
Public Member Functions | Private Attributes | List of all members
TrigTauPrecisionDiKaonHypoTool Class Reference

Precision step hypothesis tool for applying meson kinematic cuts (meson chains) More...

#include <TrigTauPrecisionDiKaonHypoTool.h>

Inheritance diagram for TrigTauPrecisionDiKaonHypoTool:
Collaboration diagram for TrigTauPrecisionDiKaonHypoTool:

Public Member Functions

 TrigTauPrecisionDiKaonHypoTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual StatusCode initialize () override
 
virtual StatusCode decide (std::vector< ITrigTauPrecisionHypoTool::ToolInfo > &input) const override
 
virtual bool decide (const ITrigTauPrecisionHypoTool::ToolInfo &i) const override
 

Private Attributes

HLT::Identifier m_decisionId
 
Gaudi::Property< float > m_ptMin {this, "PtMin", 0, "Minimum tau pT value"}
 
Gaudi::Property< int > m_numTrackMax {this, "NTracksMax", 2, "Maximum number of Tracks"}
 
Gaudi::Property< int > m_numTrackMin {this, "NTracksMin", 1, "Minimum number of Tracks"}
 
Gaudi::Property< int > m_numIsoTrackMax {this, "NIsoTracksMax", 1, "Maximum number of wide Tracks"}
 
Gaudi::Property< float > m_massTrkSysMin {this, "massTrkSysMin", 0, "Minimum DiTrack mass value"}
 
Gaudi::Property< float > m_massTrkSysMax {this, "massTrkSysMax", 1000000000, "Maximum DiTrack mass value"}
 
Gaudi::Property< float > m_massTrkSysKaonMin {this, "massTrkSysKaonMin", 0, "Minimum DiKaon mass value"}
 
Gaudi::Property< float > m_massTrkSysKaonMax {this, "massTrkSysKaonMax", 1000000000, "Maximum DiKaon mass value"}
 
Gaudi::Property< float > m_massTrkSysKaonPiMin {this, "massTrkSysKaonPiMin", 0, "Minimum KaonPi mass value"}
 
Gaudi::Property< float > m_massTrkSysKaonPiMax {this, "massTrkSysKaonPiMax", 1000000000, "Maximum KaonPi mass value"}
 
Gaudi::Property< float > m_targetMassTrkSysKaonPi {this, "targetMassTrkSysKaonPi", 0, "Target KaonPi mass value (parameter)"}
 
Gaudi::Property< float > m_leadTrkPtMin {this, "leadTrkPtMin", 0, "Minimum Pt of Lead Track"}
 
Gaudi::Property< float > m_dRmaxMax {this, "dRmaxMax", 10, "Maximum dRmax value"}
 
Gaudi::Property< float > m_etOverPtLeadTrkMax {this, "etOverPtLeadTrkMax", 10, "Maximum et/pt(lead track)"}
 
Gaudi::Property< float > m_etOverPtLeadTrkMin {this, "etOverPtLeadTrkMin", 0, "Minimum et/pt(lead track)"}
 
Gaudi::Property< float > m_EMPOverTrkSysPMax {this, "EMPOverTrkSysPMax", 5, "Maximum Cluster pt over ditrack pt"}
 
Gaudi::Property< bool > m_acceptAll {this, "AcceptAll", false, "Ignore selection"}
 
ToolHandle< GenericMonitoringTool > m_monTool {this, "MonTool", "", "Monitoring tool"}
 

Detailed Description

Precision step hypothesis tool for applying meson kinematic cuts (meson chains)

Definition at line 29 of file TrigTauPrecisionDiKaonHypoTool.h.

Constructor & Destructor Documentation

◆ TrigTauPrecisionDiKaonHypoTool()

TrigTauPrecisionDiKaonHypoTool::TrigTauPrecisionDiKaonHypoTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 26 of file TrigTauPrecisionDiKaonHypoTool.cxx.

29  : base_class(type, name, parent), m_decisionId(HLT::Identifier::fromToolName(name))
30 {
31 
32 }

Member Function Documentation

◆ decide() [1/2]

bool TrigTauPrecisionDiKaonHypoTool::decide ( const ITrigTauPrecisionHypoTool::ToolInfo &  i) const
overridevirtual

Definition at line 69 of file TrigTauPrecisionDiKaonHypoTool.cxx.

70 {
71  ATH_MSG_DEBUG(name() << ": in execute()");
72 
73  auto NInputTaus = Monitored::Scalar<int>("NInputTaus", -1);
74  auto passedCuts = Monitored::Scalar<int>("CutCounter", 0);
75  auto PtAccepted = Monitored::Scalar<float>("PtAccepted", -1);
76  auto NTracksAccepted = Monitored::Scalar<int>("NTracksAccepted", -1);
77  auto NIsoTracksAccepted = Monitored::Scalar<int>("NIsoTracksAccepted", -1);
78  auto massTrkSysAccepted = Monitored::Scalar<float>("massTrkSysAccepted", -10);
79  auto massTrkSysKaonAccepted = Monitored::Scalar<float>("massTrkSysKaonAccepted", -10);
80  auto massTrkSysKaonPiAccepted = Monitored::Scalar<float>("massTrkSysKaonPiAccepted", -10);
81  auto leadTrkPtAccepted = Monitored::Scalar<float>("leadTrkPtAccepted", -10);
82  auto dRAccepted = Monitored::Scalar<float>("dRAccepted", -1);
83  auto etOverPtLeadTrkAccepted = Monitored::Scalar<float>("etOverPtLeadTrkAccepted", -10);
84  auto EMOverTrkSysPAccepted = Monitored::Scalar<float>("EMOverTrkSysPAccepted", -10);
85 
86  auto monitorIt = Monitored::Group(m_monTool,
87  NInputTaus, passedCuts,
88  PtAccepted, NTracksAccepted, NIsoTracksAccepted,
89  massTrkSysAccepted, massTrkSysKaonAccepted, massTrkSysKaonPiAccepted,
90  leadTrkPtAccepted, dRAccepted, etOverPtLeadTrkAccepted, EMOverTrkSysPAccepted);
91 
92 
93  // Tau pass flag
94  bool pass = false;
95 
96  if(m_acceptAll) {
97  pass = true;
98  ATH_MSG_DEBUG("AcceptAll property is set: taking all events");
99  }
100 
101  // Debugging location of the TauJet RoI
102  ATH_MSG_DEBUG("Input RoI eta: " << input.roi->eta() << ", phi: " << input.roi->phi() << ", z: " << input.roi->zed());
103 
104  const xAOD::TauJetContainer* TauContainer = input.tauContainer;
105  NInputTaus = TauContainer->size();
106  // There should only be a single TauJet in the TauJetContainer; just in case we still run the loop
107  for(const xAOD::TauJet* Tau : *TauContainer) {
108  ATH_MSG_DEBUG(" New HLT TauJet candidate:");
109  passedCuts++;
110 
111 
112  //---------------------------------------------------------------
113  // Calibrated tau pT cut ('idperf' step)
114  //---------------------------------------------------------------
115  float pT = Tau->pt();
116  ATH_MSG_DEBUG(" pT: " << pT / Gaudi::Units::GeV);
117 
118  if(!(pT > m_ptMin)) continue;
119  passedCuts++;
120  PtAccepted = pT / Gaudi::Units::GeV;
121 
122 
123  //---------------------------------------------------------------
124  // Track counting ('perf' step)
125  //---------------------------------------------------------------
126  int numTrack = Tau->nTracks();
127  int numIsoTrack = Tau->nTracksIsolation();
128 
129  ATH_MSG_DEBUG(" N Tracks: " << numTrack);
130  ATH_MSG_DEBUG(" N Iso Tracks: " << numIsoTrack);
131 
132  // Apply NTrackMin/Max and NIsoTrackMax cuts:
133  if(!(numTrack >= m_numTrackMin && numTrack <= m_numTrackMax)) continue;
134  if(!(numIsoTrack <= m_numIsoTrackMax)) continue;
135  passedCuts++;
136  NTracksAccepted = numTrack;
137  NIsoTracksAccepted = numIsoTrack;
138 
139 
140  //---------------------------------------------------------------
141  // Leading track pT cut
142  //---------------------------------------------------------------
143  float leadTrkPt = -1;
144  Tau->detail(xAOD::TauJetParameters::leadTrkPt, leadTrkPt);
145  ATH_MSG_DEBUG(" leadTrkPt: " << leadTrkPt / Gaudi::Units::GeV);
146  if(!(leadTrkPt > m_leadTrkPtMin)) continue;
147  passedCuts++;
148  leadTrkPtAccepted = leadTrkPt / Gaudi::Units::GeV;
149 
150 
151  //---------------------------------------------------------------
152  // Cuts on the track-system mass, for different meson hypothesis
153  //---------------------------------------------------------------
154  float massTrkSys = -1.;
155  Tau->detail(xAOD::TauJetParameters::massTrkSys, massTrkSys);
156  ATH_MSG_DEBUG(" massTrkSys: " << massTrkSys / Gaudi::Units::GeV);
157 
158  // For the dikaon mass hypothesis, compute the invariant mass with the kaon mass
159  // Also cache the p4 of tracks, to use for other mass hypothesis
160  TLorentzVector my_kaons;
161  std::vector<TLorentzVector> my_trks;
162  for(unsigned int i = 0; i < Tau->nTracks(); ++i) {
163  const xAOD::TrackParticle* trk = nullptr;
164  TLorentzVector tmpKaon;;
165 
166  try {
167  trk = Tau->track(i)->track();
168  } catch(const std::exception& e) {
169  ATH_MSG_WARNING(" Failed to get tau track link!");
170  }
171 
172  if(trk) {
173  tmpKaon.SetPtEtaPhiM(trk->pt(), trk->eta(), trk->phi(), 493.677);
174  my_trks.push_back(trk->p4());
175  }
176 
177  my_kaons = my_kaons + tmpKaon;
178  }
179 
180  float massTrkSysKaon = my_kaons.M();
181  ATH_MSG_DEBUG(" massTrkSys with kaon mass hypo: " << massTrkSysKaon / Gaudi::Units::GeV);
182 
183  // kaon+pi mass hypo
184  float finalKPiMass = 0;
185  if(my_trks.size() == 2) {
186  TLorentzVector tmpKaon;
187 
188  tmpKaon.SetPtEtaPhiM(my_trks.at(0).Pt(), my_trks.at(0).Eta(), my_trks.at(0).Phi(), 493.677);
189  TLorentzVector tmpPion = my_trks.at(1);
190  float kPiMass1 = (tmpKaon+tmpPion).M();
191 
192  tmpKaon.SetPtEtaPhiM(my_trks.at(1).Pt(), my_trks.at(1).Eta(), my_trks.at(1).Phi(), 493.677);
193  tmpPion = my_trks.at(0);
194  float kPiMass2 = (tmpKaon+tmpPion).M();
195 
196  if(std::abs(kPiMass1 - m_targetMassTrkSysKaonPi) < std::abs(kPiMass2 - m_targetMassTrkSysKaonPi)) {
197  finalKPiMass = kPiMass1;
198  } else {
199  finalKPiMass = kPiMass2;
200  }
201  }
202  float massTrkSysKaonPi = finalKPiMass;
203  ATH_MSG_DEBUG(" massTrkSys with kaon+pi mass hypo: " << massTrkSysKaonPi / Gaudi::Units::GeV);
204 
205  if(!(massTrkSys > m_massTrkSysMin && massTrkSys < m_massTrkSysMax)) continue;
206  passedCuts++;
207  massTrkSysAccepted = massTrkSys / Gaudi::Units::GeV;
208 
209  if(!(massTrkSysKaon > m_massTrkSysKaonMin && massTrkSysKaon < m_massTrkSysKaonMax)) continue;
210  passedCuts++;
211  massTrkSysKaonAccepted = massTrkSysKaon / Gaudi::Units::GeV;
212 
213  // Use '>=' here, otherwise the singlepion chain would fail!
214  if(!(massTrkSysKaonPi >= m_massTrkSysKaonPiMin && massTrkSysKaonPi < m_massTrkSysKaonPiMax)) continue;
215  passedCuts++;
216  massTrkSysKaonPiAccepted = massTrkSysKaonPi / Gaudi::Units::GeV;
217 
218 
219  //---------------------------------------------------------------
220  // Cut on E_{T}^{EM} / p_T^{trk sys}
221  //---------------------------------------------------------------
222  float EMPOverTrkSysP = -1;
223  Tau->detail(xAOD::TauJetParameters::EMPOverTrkSysP, EMPOverTrkSysP);
224  ATH_MSG_DEBUG(" EMPOverTrkSysP: " << EMPOverTrkSysP);
225  if(!(EMPOverTrkSysP < m_EMPOverTrkSysPMax)) continue;
226  passedCuts++;
227  EMOverTrkSysPAccepted = EMPOverTrkSysP;
228 
229 
230  //---------------------------------------------------------------
231  // Cut on E_{T} / p_T^{lead trk}
232  //---------------------------------------------------------------
233  float etOverPtLeadTrk = -1;
234  Tau->detail(xAOD::TauJetParameters::etOverPtLeadTrk, etOverPtLeadTrk);
235  ATH_MSG_DEBUG(" etOverPtLeadTrk: " << etOverPtLeadTrk);
236  if(!(etOverPtLeadTrk > m_etOverPtLeadTrkMin && etOverPtLeadTrk < m_etOverPtLeadTrkMax)) continue;
237  passedCuts++;
238  etOverPtLeadTrkAccepted = etOverPtLeadTrk;
239 
240 
241  //---------------------------------------------------------------
242  // Cut on Max dR(track, tau)
243  //---------------------------------------------------------------
244  float dRmax = -1;
245  Tau->detail(xAOD::TauJetParameters::dRmax, dRmax);
246  ATH_MSG_DEBUG(" dRmax: " << dRmax);
247  if(!(dRmax < m_dRmaxMax)) continue;
248  passedCuts++;
249  dRAccepted = dRmax;
250 
251 
252  //---------------------------------------------------------
253  // At least one Tau passed all the cuts. Accept the event!
254  //---------------------------------------------------------
255  pass = true;
256 
257  ATH_MSG_DEBUG(" Pass hypo tool: " << pass);
258  }
259 
260  return pass;
261 }

◆ decide() [2/2]

StatusCode TrigTauPrecisionDiKaonHypoTool::decide ( std::vector< ITrigTauPrecisionHypoTool::ToolInfo > &  input) const
overridevirtual

Definition at line 263 of file TrigTauPrecisionDiKaonHypoTool.cxx.

264 {
265  for(auto& i : input) {
266  if(passed(m_decisionId.numeric(), i.previousDecisionIDs)) {
267  if(decide(i)) {
268  addDecisionID(m_decisionId, i.decision);
269  }
270  }
271  }
272 
273  return StatusCode::SUCCESS;
274 }

◆ initialize()

StatusCode TrigTauPrecisionDiKaonHypoTool::initialize ( )
overridevirtual

Definition at line 35 of file TrigTauPrecisionDiKaonHypoTool.cxx.

36 {
37  ATH_MSG_DEBUG(name() << ": in initialize()");
38 
39  ATH_MSG_DEBUG("TrigTauPrecisionDiKaonHypoTool will cut on:");
40  ATH_MSG_DEBUG(" - PtMin: " << m_ptMin.value());
41  ATH_MSG_DEBUG(" - NTracksMin: " << m_numTrackMin.value());
42  ATH_MSG_DEBUG(" - NTracksMax: " << m_numTrackMax.value());
43  ATH_MSG_DEBUG(" - NIsoTracksMax: " << m_numIsoTrackMax.value());
44 
45  ATH_MSG_DEBUG(" - massTrkSysMin: " << m_massTrkSysMin.value());
46  ATH_MSG_DEBUG(" - massTrkSysMax: " << m_massTrkSysMax.value());
47  ATH_MSG_DEBUG(" - massTrkSysKaonMin: " << m_massTrkSysKaonMin.value());
48  ATH_MSG_DEBUG(" - massTrkSysKaonMax: " << m_massTrkSysKaonMax.value());
49  ATH_MSG_DEBUG(" - massTrkSysKaonPiMin: " << m_massTrkSysKaonPiMin.value());
50  ATH_MSG_DEBUG(" - massTrkSysKaonPiMax: " << m_massTrkSysKaonPiMax.value());
51  ATH_MSG_DEBUG(" - targetMassTrkSysKaonPi: " << m_targetMassTrkSysKaonPi.value());
52  ATH_MSG_DEBUG(" - leadTrkPtMin: " << m_leadTrkPtMin.value());
53  ATH_MSG_DEBUG(" - dRmaxMax: " << m_dRmaxMax.value());
54  ATH_MSG_DEBUG(" - etOverPtLeadTrkMin: " << m_etOverPtLeadTrkMin.value());
55  ATH_MSG_DEBUG(" - etOverPtLeadTrkMax: " << m_etOverPtLeadTrkMax.value());
56  ATH_MSG_DEBUG(" - EMPOverTrkSysPMax: " << m_EMPOverTrkSysPMax.value());
57 
58  if(m_massTrkSysMin > m_massTrkSysMax || m_numTrackMin > m_numTrackMax
59  || m_massTrkSysKaonPiMin > m_massTrkSysKaonPiMax || m_massTrkSysKaonMin > m_massTrkSysKaonMax
60  || m_etOverPtLeadTrkMin > m_etOverPtLeadTrkMax) {
61  ATH_MSG_ERROR("Invalid tool configuration!");
62  return StatusCode::FAILURE;
63  }
64 
65  return StatusCode::SUCCESS;
66 }

Member Data Documentation

◆ m_acceptAll

Gaudi::Property<bool> TrigTauPrecisionDiKaonHypoTool::m_acceptAll {this, "AcceptAll", false, "Ignore selection"}
private

Definition at line 64 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_decisionId

HLT::Identifier TrigTauPrecisionDiKaonHypoTool::m_decisionId
private

Definition at line 40 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_dRmaxMax

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_dRmaxMax {this, "dRmaxMax", 10, "Maximum dRmax value"}
private

Definition at line 59 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_EMPOverTrkSysPMax

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_EMPOverTrkSysPMax {this, "EMPOverTrkSysPMax", 5, "Maximum Cluster pt over ditrack pt"}
private

Definition at line 62 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_etOverPtLeadTrkMax

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_etOverPtLeadTrkMax {this, "etOverPtLeadTrkMax", 10, "Maximum et/pt(lead track)"}
private

Definition at line 60 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_etOverPtLeadTrkMin

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_etOverPtLeadTrkMin {this, "etOverPtLeadTrkMin", 0, "Minimum et/pt(lead track)"}
private

Definition at line 61 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_leadTrkPtMin

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_leadTrkPtMin {this, "leadTrkPtMin", 0, "Minimum Pt of Lead Track"}
private

Definition at line 58 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_massTrkSysKaonMax

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_massTrkSysKaonMax {this, "massTrkSysKaonMax", 1000000000, "Maximum DiKaon mass value"}
private

Definition at line 52 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_massTrkSysKaonMin

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_massTrkSysKaonMin {this, "massTrkSysKaonMin", 0, "Minimum DiKaon mass value"}
private

Definition at line 51 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_massTrkSysKaonPiMax

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_massTrkSysKaonPiMax {this, "massTrkSysKaonPiMax", 1000000000, "Maximum KaonPi mass value"}
private

Definition at line 55 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_massTrkSysKaonPiMin

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_massTrkSysKaonPiMin {this, "massTrkSysKaonPiMin", 0, "Minimum KaonPi mass value"}
private

Definition at line 54 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_massTrkSysMax

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_massTrkSysMax {this, "massTrkSysMax", 1000000000, "Maximum DiTrack mass value"}
private

Definition at line 49 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_massTrkSysMin

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_massTrkSysMin {this, "massTrkSysMin", 0, "Minimum DiTrack mass value"}
private

Definition at line 48 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_monTool

ToolHandle<GenericMonitoringTool> TrigTauPrecisionDiKaonHypoTool::m_monTool {this, "MonTool", "", "Monitoring tool"}
private

Definition at line 66 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_numIsoTrackMax

Gaudi::Property<int> TrigTauPrecisionDiKaonHypoTool::m_numIsoTrackMax {this, "NIsoTracksMax", 1, "Maximum number of wide Tracks"}
private

Definition at line 45 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_numTrackMax

Gaudi::Property<int> TrigTauPrecisionDiKaonHypoTool::m_numTrackMax {this, "NTracksMax", 2, "Maximum number of Tracks"}
private

Definition at line 43 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_numTrackMin

Gaudi::Property<int> TrigTauPrecisionDiKaonHypoTool::m_numTrackMin {this, "NTracksMin", 1, "Minimum number of Tracks"}
private

Definition at line 44 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_ptMin

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_ptMin {this, "PtMin", 0, "Minimum tau pT value"}
private

Definition at line 42 of file TrigTauPrecisionDiKaonHypoTool.h.

◆ m_targetMassTrkSysKaonPi

Gaudi::Property<float> TrigTauPrecisionDiKaonHypoTool::m_targetMassTrkSysKaonPi {this, "targetMassTrkSysKaonPi", 0, "Target KaonPi mass value (parameter)"}
private

Definition at line 56 of file TrigTauPrecisionDiKaonHypoTool.h.

The documentation for this class was generated from the following files:
TrigTauPrecisionDiKaonHypoTool::m_massTrkSysMax
Gaudi::Property< float > m_massTrkSysMax
Definition: TrigTauPrecisionDiKaonHypoTool.h:49
TrigTauPrecisionDiKaonHypoTool::m_numTrackMin
Gaudi::Property< int > m_numTrackMin
Definition: TrigTauPrecisionDiKaonHypoTool.h:44
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
TrigTauPrecisionDiKaonHypoTool::m_numIsoTrackMax
Gaudi::Property< int > m_numIsoTrackMax
Definition: TrigTauPrecisionDiKaonHypoTool.h:45
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
TrigTauPrecisionDiKaonHypoTool::m_EMPOverTrkSysPMax
Gaudi::Property< float > m_EMPOverTrkSysPMax
Definition: TrigTauPrecisionDiKaonHypoTool.h:62
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
HLT::Identifier::numeric
TrigCompositeUtils::DecisionID numeric() const
numeric ID
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:47
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
TrigTauPrecisionDiKaonHypoTool::decide
virtual StatusCode decide(std::vector< ITrigTauPrecisionHypoTool::ToolInfo > &input) const override
Definition: TrigTauPrecisionDiKaonHypoTool.cxx:263
TrigCompositeUtils::addDecisionID
void addDecisionID(DecisionID id, Decision *d)
Appends the decision (given as ID) to the decision object.
Definition: TrigCompositeUtilsRoot.cxx:61
TrigTauPrecisionDiKaonHypoTool::m_decisionId
HLT::Identifier m_decisionId
Definition: TrigTauPrecisionDiKaonHypoTool.h:40
TrigTauPrecisionDiKaonHypoTool::m_ptMin
Gaudi::Property< float > m_ptMin
Definition: TrigTauPrecisionDiKaonHypoTool.h:42
Tau
Definition: EfficiencyPtPlots.cxx:9
TrigTauPrecisionDiKaonHypoTool::m_etOverPtLeadTrkMin
Gaudi::Property< float > m_etOverPtLeadTrkMin
Definition: TrigTauPrecisionDiKaonHypoTool.h:61
HLT::Identifier::fromToolName
static HLT::Identifier fromToolName(const std::string &tname)
Definition: HLTIdentifier.cxx:31
xAOD::TauJetParameters::dRmax
@ dRmax
Get maximal dR of tracks associated to calo-seeded tau.
Definition: TauDefs.h:226
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:129
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
TrigTauPrecisionDiKaonHypoTool::m_massTrkSysKaonMax
Gaudi::Property< float > m_massTrkSysKaonMax
Definition: TrigTauPrecisionDiKaonHypoTool.h:52
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
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
calibdata.exception
exception
Definition: calibdata.py:496
test_pyathena.parent
parent
Definition: test_pyathena.py:15
xAOD::TauJetParameters::etOverPtLeadTrk
@ etOverPtLeadTrk
Definition: TauDefs.h:158
TrigTauPrecisionDiKaonHypoTool::m_massTrkSysKaonPiMax
Gaudi::Property< float > m_massTrkSysKaonPiMax
Definition: TrigTauPrecisionDiKaonHypoTool.h:55
TrigTauPrecisionDiKaonHypoTool::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: TrigTauPrecisionDiKaonHypoTool.h:66
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
xAOD::TauJetParameters::massTrkSys
@ massTrkSys
Definition: TauDefs.h:161
TrigTauPrecisionDiKaonHypoTool::m_etOverPtLeadTrkMax
Gaudi::Property< float > m_etOverPtLeadTrkMax
Definition: TrigTauPrecisionDiKaonHypoTool.h:60
TrigTauPrecisionDiKaonHypoTool::m_targetMassTrkSysKaonPi
Gaudi::Property< float > m_targetMassTrkSysKaonPi
Definition: TrigTauPrecisionDiKaonHypoTool.h:56
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
TrigTauPrecisionDiKaonHypoTool::m_massTrkSysKaonMin
Gaudi::Property< float > m_massTrkSysKaonMin
Definition: TrigTauPrecisionDiKaonHypoTool.h:51
TrigTauPrecisionDiKaonHypoTool::m_dRmaxMax
Gaudi::Property< float > m_dRmaxMax
Definition: TrigTauPrecisionDiKaonHypoTool.h:59
TrigTauPrecisionDiKaonHypoTool::m_massTrkSysMin
Gaudi::Property< float > m_massTrkSysMin
Definition: TrigTauPrecisionDiKaonHypoTool.h:48
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TrigTauPrecisionDiKaonHypoTool::m_numTrackMax
Gaudi::Property< int > m_numTrackMax
Definition: TrigTauPrecisionDiKaonHypoTool.h:43
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TrigTauPrecisionDiKaonHypoTool::m_leadTrkPtMin
Gaudi::Property< float > m_leadTrkPtMin
Definition: TrigTauPrecisionDiKaonHypoTool.h:58
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
TrigTauPrecisionDiKaonHypoTool::m_acceptAll
Gaudi::Property< bool > m_acceptAll
Definition: TrigTauPrecisionDiKaonHypoTool.h:64
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TrigTauPrecisionDiKaonHypoTool::m_massTrkSysKaonPiMin
Gaudi::Property< float > m_massTrkSysKaonPiMin
Definition: TrigTauPrecisionDiKaonHypoTool.h:54
xAOD::TauJetParameters::EMPOverTrkSysP
@ EMPOverTrkSysP
Definition: TauDefs.h:279
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
xAOD::TauJetParameters::leadTrkPt
@ leadTrkPt
Definition: TauDefs.h:159
Generated on Mon Dec 23 2024 21:53:38 for ATLAS Offline Software by   doxygen 1.8.18