ATLAS Offline Software
JetForwardJvtToolBDT.cxx
Go to the documentation of this file.
1 /*
3  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
4 */
5 // JetForwardJvtToolBDT.cxx
6 // Implementation file for class JetForwardJvtToolBDT
7 // Author: Louis Portales <louis.portales@cern.ch>
9 
10 // JetForwardJvtToolBDT includes
11 #include "JetMomentTools/JetForwardJvtToolBDT.h"
12 // Jet EDM
13 #include "xAODJet/JetAttributes.h"
14 #include "AthContainers/ConstAccessor.h"
15 #include "PathResolver/PathResolver.h"
16 #include "CxxUtils/checker_macros.h"
17 #include <mutex>
18 
19 
20 const double GeV = 1000.;
22 // Public methods:
24 
25 // Constructors
27 JetForwardJvtToolBDT::JetForwardJvtToolBDT(const std::string& name) :
28  asg::AsgTool(name)
29 {
30 }
31 
32 // Destructor
34 JetForwardJvtToolBDT::~JetForwardJvtToolBDT()= default;
35 
36 // Athena algtool's Hooks
38 StatusCode JetForwardJvtToolBDT::initialize()
39 {
40  ATH_MSG_INFO ("Initializing " << name() << "...");
41 
42  if(m_isAna){
43  // -- Retrieve MVfJVT WP configFile ONLY if tool used in 'Analysis mode'
44  std::string filename = PathResolverFindCalibFile(std::string(m_configDir)+m_wpFile);
45  if (filename.empty()){
46  ATH_MSG_ERROR ( "Could NOT resolve file name " << m_wpFile);
47  return StatusCode::FAILURE;
48  } else{
49  ATH_MSG_INFO(" Config Files Path found = "<<filename);
50  }
51 
52  // -- Retrieve WP histograms
53  m_wpFileIn = std::make_unique<TFile> (filename.c_str(),"read");
54 
55  if ( m_OP=="TIGHTER") {
56  m_mvfjvtThresh = std::unique_ptr< TH3D >( dynamic_cast<TH3D*>( m_wpFileIn->Get( "MVfJVT_tighter" ) ) );
57  } else if ( m_OP=="TIGHT" ) {
58  m_mvfjvtThresh = std::unique_ptr< TH3D >( dynamic_cast<TH3D*>( m_wpFileIn->Get( "MVfJVT_tight" ) ) );
59  } else if ( m_OP=="DEFAULT" || m_OP=="LOOSE" ) {
60  m_mvfjvtThresh = std::unique_ptr< TH3D >( dynamic_cast<TH3D*>( m_wpFileIn->Get( "MVfJVT_loose" ) ) );
61  } else {
62  ATH_MSG_ERROR(m_OP << " working point doesn't exist." );
63  return StatusCode::FAILURE;
64  }
65  m_mvfjvtThresh->SetDirectory(nullptr);
66  m_wpFileIn->Close();
67  }
68 
69  // -- Setup the tagger
70  m_MVreader = std::make_unique< TMVA::Reader > ( "Silent" );
71  float fjvt,width,time,cllambda2,cletawidth,cle,cliso,clemprob;
72  m_MVreader->AddVariable( "fjvtdist", &fjvt );
73  m_MVreader->AddVariable( "Width_jet", &width );
74  m_MVreader->AddVariable( "timedist", &time );
75  m_MVreader->AddVariable( "jet_LeadingClusterSecondLambda", &cllambda2 );
76  m_MVreader->AddVariable( "cl_etaWidthLead", &cletawidth );
77  m_MVreader->AddVariable( "clsum_e", &cle );
78  m_MVreader->AddVariable( "cl_ISOLATIONsumE", &cliso );
79  m_MVreader->AddVariable( "cl_EM_PROBABILITYsumE", &clemprob );
80  for(unsigned int i = 0; i<m_MVconfig.size(); ++i) m_MVreader->BookMVA(TString::Format("BDT_%i",i+1),PathResolverFindCalibFile(m_configDir+m_MVconfig.value().at(i)));
81 
82  // "passMVfJVT" flag
83  m_outMVKey = m_jetContainerName + "." + m_outMVKey.key();
84  ATH_CHECK(m_outMVKey.initialize());
85 
86  // Moments values
87  m_mvfjvtKey = m_jetContainerName + "." + m_mvfjvtKey.key();
88  ATH_CHECK(m_mvfjvtKey.initialize());
89 
90  m_cllambda2Key = m_jetContainerName + "." + m_cllambda2Key.key();
91  m_clwidthKey = m_jetContainerName + "." + m_clwidthKey.key();
92  m_clisoKey = m_jetContainerName + "." + m_clisoKey.key();
93  m_clemprobKey = m_jetContainerName + "." + m_clemprobKey.key();
94  m_cleKey = m_jetContainerName + "." + m_cleKey.key();
95 
96  ATH_CHECK(m_cllambda2Key.initialize());
97  ATH_CHECK(m_clwidthKey.initialize());
98  ATH_CHECK(m_clisoKey.initialize());
99  ATH_CHECK(m_clemprobKey.initialize());
100  ATH_CHECK(m_cleKey.initialize());
101 
102  m_lcllambda2Key = m_jetContainerName + "." + m_lcllambda2Key.key();
103  m_lcllambda2NTKey = m_jetContainerName + "." + m_lcllambda2NTKey.key();
104  m_lclwidthKey = m_jetContainerName + "." + m_lclwidthKey.key();
105  m_lclisoKey = m_jetContainerName + "." + m_lclisoKey.key();
106  m_lclemprobKey = m_jetContainerName + "." + m_lclemprobKey.key();
107  m_lcleKey = m_jetContainerName + "." + m_lcleKey.key();
108 
109  ATH_CHECK(m_lcllambda2Key.initialize());
110  ATH_CHECK(m_lcllambda2NTKey.initialize());
111  ATH_CHECK(m_lclwidthKey.initialize());
112  ATH_CHECK(m_lclisoKey.initialize());
113  ATH_CHECK(m_lclemprobKey.initialize());
114  ATH_CHECK(m_lcleKey.initialize());
115 
116  ATH_CHECK(m_eventInfoKey.initialize());
117  ATH_CHECK(m_vertexContainerKey.initialize());
118  ATH_CHECK(m_caloClusterContainerKey.initialize());
119  ATH_CHECK(m_trkMetKey.initialize());
120 
121  // Truth information
122  m_isHSKey = m_jetContainerName + "." + m_isHSKey.key();
123  m_isPUKey = m_jetContainerName + "." + m_isPUKey.key();
124 
125  ATH_CHECK(m_isHSKey.initialize());
126  ATH_CHECK(m_isPUKey.initialize());
127 
128  return StatusCode::SUCCESS;
129 }
130 
131 
132 StatusCode JetForwardJvtToolBDT::decorate(const xAOD::JetContainer& jetCont) const {
133 
134  // -- Retrieve PV index if not provided by user
135  //pvind = (m_pvind.value()==-1) ? getPV() : m_pvind;
136  int pvind = m_pvind.value();
137  if(pvind == -1) pvind = getPV();
138 
139  ATH_MSG_DEBUG("In JetForwardJvtToolBDT::modify: PV index = " << pvind);
140  if( pvind == -1 ){
141  ATH_MSG_WARNING( "Something went wrong with the HS primary vertex identification." );
142  return StatusCode::FAILURE;
143  }
144 
145  SG::WriteDecorHandle<xAOD::JetContainer, char> outMVHandle(m_outMVKey);
146  SG::WriteDecorHandle<xAOD::JetContainer, float> mvfjvtHandle(m_mvfjvtKey);
147 
148  SG::WriteDecorHandle<xAOD::JetContainer, float> cllambda2Handle(m_cllambda2Key);
149  SG::WriteDecorHandle<xAOD::JetContainer, float> clwidthHandle(m_clwidthKey);
150  SG::WriteDecorHandle<xAOD::JetContainer, float> clisoHandle(m_clisoKey);
151  SG::WriteDecorHandle<xAOD::JetContainer, float> clemprobHandle(m_clemprobKey);
152  SG::WriteDecorHandle<xAOD::JetContainer, float> cleHandle(m_cleKey);
153  std::vector<TVector2> pileupMomenta;
154  for(const xAOD::Jet *jetF : jetCont) {
155 
156  float mvfjvt = -2;
157  outMVHandle(*jetF) = 1;
158  cllambda2Handle(*jetF) = 0;
159  clwidthHandle(*jetF) = 0;
160  cleHandle(*jetF) = 0;
161  clisoHandle(*jetF) = 0;
162  clemprobHandle(*jetF) = 0;
163 
164  // -- Get PU vertices momenta sums, then compute tagger value for forward jets
165  if ( forwardJet(jetF) ){
166  if( pileupMomenta.empty() ) {
167  pileupMomenta = calculateVertexMomenta(&jetCont, pvind);
168  if( pileupMomenta.empty() ) {
169  ATH_MSG_DEBUG( "pileupMomenta is empty, this can happen for events with no PU vertices. fJVT won't be computed for this event and will be set to 0 instead." );
170  mvfjvtHandle(*jetF) = 0;
171  continue;
172  }
173  }
174  mvfjvt = getMVfJVT(jetF, pvind, pileupMomenta);
175  if(m_isAna) outMVHandle(*jetF) = passMVfJVT( mvfjvt, jetF->pt()/(GeV), fabs(jetF->eta()) );
176  mvfjvtHandle(*jetF) = mvfjvt;
177  }
178  }
179  return StatusCode::SUCCESS;
180 
181 }
182 
183 
184 float JetForwardJvtToolBDT::getFJVT(const xAOD::Jet *jet, int pvind, const std::vector<TVector2>& pileupMomenta) const {
185 
186  TVector2 fjet(-jet->pt()*cos(jet->phi()),-jet->pt()*sin(jet->phi()));
187  double fjvt = 0;
188  ATH_MSG_DEBUG("In JetForwardJvtToolBDT::getFJVT -----> Starting looping on vertices (pileupMomenta.size() = "<<pileupMomenta.size());
189  for (size_t pui = 0; pui < pileupMomenta.size(); pui++) {
190  if (pui!=(size_t)pvind){
191  double projection = pileupMomenta[pui]*fjet/fjet.Mod();
192  if (projection>fjvt) fjvt = projection;
193  }
194  }
195  return fjvt;
196 }
197 
198 
199 float JetForwardJvtToolBDT::getMVfJVT(const xAOD::Jet *jet, int pvind, const std::vector<TVector2>& pileupMomenta) const {
200 
201  static const SG::ConstAccessor<float> MVfJVTAcc ("MVfJVT");
202  if(m_isAna && !m_getTagger) return MVfJVTAcc(*jet);
203 
204  StatusCode sc = getInputs(jet);
205  if( sc.isFailure() ) {
206  ATH_MSG_WARNING(" Could not calculate BDT inputs");
207  return -2;
208  }
209 
210  SG::ReadHandle<xAOD::EventInfo> eventInfoHandle(m_eventInfoKey);
211  if ( !eventInfoHandle.isValid() ) {
212  ATH_MSG_WARNING(" xAOD::EventInfo " << m_eventInfoKey.key() << "is invalid");
213  return -2;
214  }
215  float mu = eventInfoHandle->actualInteractionsPerCrossing();
216 
217  if (!forwardJet(jet)) return -2;
218 
219  SG::WriteDecorHandle<xAOD::JetContainer, float> cllambda2Handle(m_cllambda2Key);
220  SG::WriteDecorHandle<xAOD::JetContainer, float> clwidthHandle(m_clwidthKey);
221  SG::WriteDecorHandle<xAOD::JetContainer, float> clisoHandle(m_clisoKey);
222  SG::WriteDecorHandle<xAOD::JetContainer, float> clemprobHandle(m_clemprobKey);
223  SG::WriteDecorHandle<xAOD::JetContainer, float> cleHandle(m_cleKey);
224 
225  std::vector<float> MVinputs;
226  MVinputs.push_back( getFJVT(jet, pvind, pileupMomenta)/jet->pt() );
227  MVinputs.push_back( jet->getAttribute<float>("Width") );
228  MVinputs.push_back( jet->getAttribute<float>("Timing") );
229  MVinputs.push_back( cllambda2Handle(*jet) );
230  MVinputs.push_back( clwidthHandle(*jet) );
231  MVinputs.push_back( cleHandle(*jet) );
232  MVinputs.push_back( clisoHandle(*jet) );
233  MVinputs.push_back( clemprobHandle(*jet) );
234 
235  float pt = jet->pt()/(GeV);
236  float eta = fabs(jet->eta());
237 
238  float score = -2.;
239  // TMVA::Reader::EvaluateMVA isn't thread-safe.
240  TMVA::Reader& reader ATLAS_THREAD_SAFE = *m_MVreader;
241  static std::mutex mutex;
242  std::lock_guard lock (mutex);
243  if ( pt < 30. && pt >= 20. && eta >= 3.2 && mu>=50. ) score = reader.EvaluateMVA( MVinputs, "BDT_1" ,1.);
244  else if ( pt < 30. && pt >= 20. && eta < 3.2 && mu>=50. ) score = reader.EvaluateMVA( MVinputs, "BDT_2" ,1.);
245  else if ( pt < 40. && pt >= 30. && eta >= 3.2 && mu>=50. ) score = reader.EvaluateMVA( MVinputs, "BDT_3" ,1.);
246  else if ( pt < 40. && pt >= 30. && eta < 3.2 && mu>=50. ) score = reader.EvaluateMVA( MVinputs, "BDT_4" ,1.);
247  else if ( pt < 50. && pt >= 40. && eta >= 3.2 && mu>=50. ) score = reader.EvaluateMVA( MVinputs, "BDT_5" ,1.);
248  else if ( pt < 50. && pt >= 40. && eta < 3.2 && mu>=50. ) score = reader.EvaluateMVA( MVinputs, "BDT_6" ,1.);
249  else if ( pt < 120. && pt >= 50. && eta >= 3.2 && mu>=50. ) score = reader.EvaluateMVA( MVinputs, "BDT_7" ,1.);
250  else if ( pt < 120. && pt >= 50. && eta < 3.2 && mu>=50. ) score = reader.EvaluateMVA( MVinputs, "BDT_8" ,1.);
251  else if ( pt < 30. && pt >= 20. && eta >= 3.2 && mu<50. ) score = reader.EvaluateMVA( MVinputs, "BDT_9" ,1.);
252  else if ( pt < 30. && pt >= 20. && eta < 3.2 && mu<50. ) score = reader.EvaluateMVA( MVinputs, "BDT_10" ,1.);
253  else if ( pt < 40. && pt >= 30. && eta >= 3.2 && mu<50. ) score = reader.EvaluateMVA( MVinputs, "BDT_11" ,1.);
254  else if ( pt < 40. && pt >= 30. && eta < 3.2 && mu<50. ) score = reader.EvaluateMVA( MVinputs, "BDT_12" ,1.);
255  else if ( pt < 50. && pt >= 40. && eta >= 3.2 && mu<50. ) score = reader.EvaluateMVA( MVinputs, "BDT_13" ,1.);
256  else if ( pt < 50. && pt >= 40. && eta < 3.2 && mu<50. ) score = reader.EvaluateMVA( MVinputs, "BDT_14" ,1.);
257  else if ( pt < 120. && pt >= 50. && eta >= 3.2 && mu<50. ) score = reader.EvaluateMVA( MVinputs, "BDT_15" ,1.);
258  else if ( pt < 120. && pt >= 50. && eta < 3.2 && mu<50. ) score = reader.EvaluateMVA( MVinputs, "BDT_16" ,1.);
259 
260  ATH_MSG_DEBUG("pt = " << pt << " | eta = " << eta << " | mu = " << mu << " || MVfJVT = " << score );
261 
262  return score;
263 }
264 
265 bool JetForwardJvtToolBDT::passMVfJVT( float mvfjvt, float pt, float eta ) const {
266 
267  double mvfjvtThresh = -999.;
268 
269  SG::ReadHandle<xAOD::EventInfo> eventInfoHandle(m_eventInfoKey);
270  if ( !eventInfoHandle.isValid() ) {
271  ATH_MSG_WARNING(" xAOD::EventInfo " << m_eventInfoKey.key() << "is invalid");
272  return true;
273  }
274 
275  float mu = eventInfoHandle->actualInteractionsPerCrossing();
276 
277  // -- Grab WP from histogram
278  mvfjvtThresh = m_mvfjvtThresh->GetBinContent(m_mvfjvtThresh->GetXaxis()->FindBin(pt),
279  m_mvfjvtThresh->GetYaxis()->FindBin(eta),
280  m_mvfjvtThresh->GetZaxis()->FindBin(mu));
281 
282  return mvfjvt==-2 || mvfjvt>mvfjvtThresh;
283 
284 }
285 
286 StatusCode JetForwardJvtToolBDT::getInputs(const xAOD::Jet *jet) const {
287  SG::WriteDecorHandle<xAOD::JetContainer, float> cllambda2Handle(m_cllambda2Key);
288  SG::WriteDecorHandle<xAOD::JetContainer, float> clwidthHandle(m_clwidthKey);
289  SG::WriteDecorHandle<xAOD::JetContainer, float> clisoHandle(m_clisoKey);
290  SG::WriteDecorHandle<xAOD::JetContainer, float> clemprobHandle(m_clemprobKey);
291  SG::WriteDecorHandle<xAOD::JetContainer, float> cleHandle(m_cleKey);
292 
293  if(!m_getTagger){
294  SG::ReadDecorHandle<xAOD::JetContainer, float> lcllambda2NTHandle(m_lcllambda2NTKey);
295  cllambda2Handle(*jet) = lcllambda2NTHandle(*jet);
296 
297  // -- Additional variables computed from cluster information
298  SG::ReadHandle<xAOD::CaloClusterContainer> clustersHandle(m_caloClusterContainerKey);
299  if( !clustersHandle.isValid() ) {
300  ATH_MSG_ERROR(" xAOD::CaloClusterContainer " << m_caloClusterContainerKey.key() << "is invalid");
301  return StatusCode::FAILURE;
302  }
303 
304  int ind = 0;
305  float maxpt = 0;
306  float cle1 = 0;
307  float cliso1 = 0;
308  float clemprob1 = 0;
309  float cle2 = 0;
310 
311  // Loop over clusters within DeltaR<0.6 of the jet axis to compute the (energy-weighted) moment sums used in the BDT definitions
312  static const SG::ConstAccessor<float> ISOLATIONAcc ("ISOLATION");
313  static const SG::ConstAccessor<float> EM_PROBABILITYAcc ("EM_PROBABILITY");
314  for (const xAOD::CaloCluster *cl: *clustersHandle) {
315  if(cl->p4().DeltaR(jet->p4())>0.6) continue;
316  cle1 += cl->e();
317  cle2 += cl->e()*cl->e();
318  cliso1 += ISOLATIONAcc(*cl)*cl->e()*cl->e();
319  clemprob1 += EM_PROBABILITYAcc(*cl)*cl->e()*cl->e();
320  if(cl->rawE()/cosh(cl->rawEta()) > maxpt){
321  maxpt = cl->rawE()/cosh(cl->rawEta());
322  ind = cl->index();
323  }
324  }
325  const xAOD::CaloCluster *cl = clustersHandle->at(ind);
326  static const SG::ConstAccessor<float> SECOND_RAcc ("SECOND_R");
327  static const SG::ConstAccessor<float> CENTER_MAGAcc ("CENTER_MAG");
328  clwidthHandle(*jet) = TMath::CosH(cl->rawEta()) * TMath::ATan2( TMath::Sqrt(SECOND_RAcc(*cl)),
329  CENTER_MAGAcc(*cl));
330 
331  cleHandle(*jet) = cle1;
332  clisoHandle(*jet)= cliso1/cle2;
333  clemprobHandle(*jet) =clemprob1/cle2;
334 
335  } else {
336  SG::ReadDecorHandle<xAOD::JetContainer, float> lcllambda2Handle(m_lcllambda2Key);
337  SG::ReadDecorHandle<xAOD::JetContainer, float> lclwidthHandle(m_lclwidthKey);
338  SG::ReadDecorHandle<xAOD::JetContainer, float> lclisoHandle(m_lclisoKey);
339  SG::ReadDecorHandle<xAOD::JetContainer, float> lclemprobHandle(m_lclemprobKey);
340  SG::ReadDecorHandle<xAOD::JetContainer, float> lcleHandle(m_lcleKey);
341 
342  cllambda2Handle(*jet) = lcllambda2Handle(*jet);
343  clwidthHandle(*jet) = lclwidthHandle(*jet);
344  clisoHandle(*jet) = lclisoHandle(*jet);
345  clemprobHandle(*jet) = lclemprobHandle(*jet);
346  cleHandle(*jet) = lcleHandle(*jet);
347  }
348  return StatusCode::SUCCESS;
349 }
350 
351 std::vector<TVector2> JetForwardJvtToolBDT::calculateVertexMomenta(const xAOD::JetContainer *jets, int pvind) const {
352 
353  std::vector<TVector2> pileupMomenta;
354 
355  SG::ReadHandle<xAOD::MissingETContainer> trkMetHandle(m_trkMetKey);
356  if( !trkMetHandle.isValid() ) {
357  ATH_MSG_WARNING(" xAOD::MissingETContainer " << m_trkMetKey.key() << "is invalid");
358  return pileupMomenta;
359  }
360  SG::ReadHandle<xAOD::VertexContainer> vxContHandle(m_vertexContainerKey);
361  if( !vxContHandle.isValid() ) {
362  ATH_MSG_WARNING(" xAOD::VertexContainer " << m_vertexContainerKey.key() << "is invalid");
363  return pileupMomenta;
364  }
365  ATH_MSG_DEBUG("In JetForwardJvtToolBDT::calculateVertexMomenta : Starting vertex loop ");
366  for(const xAOD::Vertex *vx : *vxContHandle) {
367  ATH_MSG_DEBUG(" --> VertexType="<<vx->vertexType());
368  if(vx->vertexType()!=xAOD::VxType::PriVtx && vx->vertexType()!=xAOD::VxType::PileUp) continue;
369  TString vname = "PVTrack_vx";
370  vname += vx->index();
371  pileupMomenta.push_back((vx->index()==(size_t)pvind?0:-(1./m_jetScaleFactor))*TVector2(0.5*(*trkMetHandle)[vname.Data()]->mpx(),0.5*(*trkMetHandle)[vname.Data()]->mpy()));
372  }
373  for (const xAOD::Jet *jet : *jets) {
374  if (!centralJet(jet)) continue;
375  int jetvert = getJetVertex(jet);
376  if (jetvert>=0) pileupMomenta[jetvert] += TVector2(0.5*jet->pt()*cos(jet->phi()),0.5*jet->pt()*sin(jet->phi()));
377  }
378 
379  return pileupMomenta;
380 }
381 
382 bool JetForwardJvtToolBDT::forwardJet(const xAOD::Jet *jet) const {
383 
384  if (fabs(jet->eta())<m_etaThresh) return false;
385  if (jet->pt()<m_forwardMinPt || jet->pt()>m_forwardMaxPt) return false;
386  return true;
387 }
388 
389 bool JetForwardJvtToolBDT::centralJet(const xAOD::Jet *jet) const {
390 
391  if (fabs(jet->eta())>m_etaThresh) return false;
392  if (jet->pt()<m_centerMinPt || (m_centerMaxPt>0 && jet->pt()>m_centerMaxPt)) return false;
393  float jvt = 0;
394  jet->getAttribute<float>(m_jvtMomentName,jvt);
395  if (jvt>m_centerJvtThresh) return false;
396  if (jet->pt()<m_maxStochPt && getDrpt(jet)<m_centerDrptThresh) return false;
397  return true;
398 }
399 
400 int JetForwardJvtToolBDT::getJetVertex(const xAOD::Jet *jet) const {
401 
402  std::vector<float> sumpts;
403  jet->getAttribute<std::vector<float> >("SumPtTrkPt500",sumpts);
404  double firstVal = 0;
405  int bestMatch = -1;
406  for (size_t i = 0; i < sumpts.size(); i++) {
407  if (sumpts[i]>firstVal) {
408  bestMatch = i;
409  firstVal = sumpts[i];
410  }
411  }
412  return bestMatch;
413 }
414 
415 float JetForwardJvtToolBDT::getDrpt(const xAOD::Jet *jet) const {
416 
417  std::vector<float> sumpts;
418  jet->getAttribute<std::vector<float> >("SumPtTrkPt500",sumpts);
419  if (sumpts.size()<2) return 0;
420 
421  std::nth_element(sumpts.begin(),sumpts.begin()+sumpts.size()/2,sumpts.end(),std::greater<int>());
422  double median = sumpts[sumpts.size()/2];
423  std::nth_element(sumpts.begin(),sumpts.begin(),sumpts.end(),std::greater<int>());
424  double max = sumpts[0];
425  return (max-median)/jet->pt();
426 }
427 
428 int JetForwardJvtToolBDT::getPV() const{
429 
430  SG::ReadHandle<xAOD::VertexContainer> vxContHandle(m_vertexContainerKey);
431  if( !vxContHandle.isValid() ) {
432  ATH_MSG_WARNING(" xAOD::VertexContainer " << m_vertexContainerKey.key() << "is invalid");
433  return 0;
434  } else {
435  ATH_MSG_DEBUG("Successfully retrieved primary vertex container");
436  for(const xAOD::Vertex *vx : *vxContHandle) {
437  if(vx->vertexType()==xAOD::VxType::PriVtx) return vx->index();
438  }
439  }
440  ATH_MSG_DEBUG("Couldn't identify the hard-scatter primary vertex (no vertex with \"vx->vertexType()==xAOD::VxType::PriVtx\" in the container)!");
441  return 0;
442 }
443 
444 StatusCode JetForwardJvtToolBDT::tagTruth(const xAOD::JetContainer *jets,const xAOD::JetContainer *truthJets) {
445  SG::WriteDecorHandle<xAOD::JetContainer, char> isHSHandle(m_isHSKey);
446  SG::WriteDecorHandle<xAOD::JetContainer, char> isPUHandle(m_isPUKey);
447 
448  for(const xAOD::Jet *jet : *jets) {
449  bool ishs = false;
450  bool ispu = true;
451  for(const xAOD::Jet *tjet : *truthJets) {
452  if (tjet->p4().DeltaR(jet->p4())<0.3 && tjet->pt()>10e3) ishs = true;
453  if (tjet->p4().DeltaR(jet->p4())<0.6) ispu = false;
454  }
455  isHSHandle(*jet)=ishs;
456  isPUHandle(*jet)=ispu;
457  }
458  return StatusCode::SUCCESS;
459 }
JetForwardJvtToolBDT::m_lcllambda2Key
SG::ReadDecorHandleKey< xAOD::JetContainer > m_lcllambda2Key
Definition: JetForwardJvtToolBDT.h:135
JetForwardJvtToolBDT::m_isHSKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_isHSKey
Definition: JetForwardJvtToolBDT.h:146
JetForwardJvtToolBDT::m_etaThresh
Gaudi::Property< double > m_etaThresh
Definition: JetForwardJvtToolBDT.h:108
JetForwardJvtToolBDT::m_lclisoKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_lclisoKey
Definition: JetForwardJvtToolBDT.h:137
JetForwardJvtToolBDT::m_mvfjvtThresh
std::unique_ptr< TH3D > m_mvfjvtThresh
Definition: JetForwardJvtToolBDT.h:106
JetForwardJvtToolBDT::m_mvfjvtKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_mvfjvtKey
Definition: JetForwardJvtToolBDT.h:127
JetForwardJvtToolBDT::m_centerMaxPt
Gaudi::Property< double > m_centerMaxPt
Definition: JetForwardJvtToolBDT.h:112
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
JetForwardJvtToolBDT::m_clwidthKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_clwidthKey
Definition: JetForwardJvtToolBDT.h:129
JetForwardJvtToolBDT::m_configDir
Gaudi::Property< std::string > m_configDir
Definition: JetForwardJvtToolBDT.h:83
JetForwardJvtToolBDT::centralJet
bool centralJet(const xAOD::Jet *jet) const
Definition: JetForwardJvtToolBDT.cxx:389
JetForwardJvtToolBDT::getDrpt
float getDrpt(const xAOD::Jet *jet) const
Definition: JetForwardJvtToolBDT.cxx:415
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
BeamSpot::mutex
std::mutex mutex
Definition: InDetBeamSpotVertex.cxx:18
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
StateLessPT_NewConfig.Format
Format
Definition: StateLessPT_NewConfig.py:149
JetForwardJvtToolBDT::~JetForwardJvtToolBDT
virtual ~JetForwardJvtToolBDT()
Destructor:
JetAttributes.h
asg
Definition: DataHandleTestTool.h:28
test_pyathena.pt
pt
Definition: test_pyathena.py:11
defineDB.jets
jets
Definition: JetTagCalibration/share/defineDB.py:24
JetForwardJvtToolBDT::m_pvind
Gaudi::Property< int > m_pvind
Definition: JetForwardJvtToolBDT.h:121
InDet::median
float median(std::vector< float > &Vec)
Definition: BTagVrtSec.cxx:35
SG::ConstAccessor< float >
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
JetForwardJvtToolBDT::m_outMVKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_outMVKey
Definition: JetForwardJvtToolBDT.h:125
JetForwardJvtToolBDT::m_getTagger
Gaudi::Property< bool > m_getTagger
Definition: JetForwardJvtToolBDT.h:119
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
JetForwardJvtToolBDT::getJetVertex
int getJetVertex(const xAOD::Jet *jet) const
Definition: JetForwardJvtToolBDT.cxx:400
JetForwardJvtToolBDT::m_cllambda2Key
SG::WriteDecorHandleKey< xAOD::JetContainer > m_cllambda2Key
Definition: JetForwardJvtToolBDT.h:128
JetForwardJvtToolBDT::getInputs
StatusCode getInputs(const xAOD::Jet *jet) const
Definition: JetForwardJvtToolBDT.cxx:286
JetForwardJvtToolBDT::m_forwardMinPt
Gaudi::Property< double > m_forwardMinPt
Definition: JetForwardJvtToolBDT.h:109
JetForwardJvtToolBDT::m_trkMetKey
SG::ReadHandleKey< xAOD::MissingETContainer > m_trkMetKey
Definition: JetForwardJvtToolBDT.h:144
JetForwardJvtToolBDT::m_lcllambda2NTKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_lcllambda2NTKey
Definition: JetForwardJvtToolBDT.h:134
JetForwardJvtToolBDT::decorate
virtual StatusCode decorate(const xAOD::JetContainer &jetCont) const override
Decorate a jet collection without otherwise modifying it.
Definition: JetForwardJvtToolBDT.cxx:132
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
JetForwardJvtToolBDT.h
JetForwardJvtToolBDT::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: JetForwardJvtToolBDT.h:141
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
JetForwardJvtToolBDT::m_centerMinPt
Gaudi::Property< double > m_centerMinPt
Definition: JetForwardJvtToolBDT.h:111
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
JetForwardJvtToolBDT::calculateVertexMomenta
std::vector< TVector2 > calculateVertexMomenta(const xAOD::JetContainer *jets, int pvind) const
Definition: JetForwardJvtToolBDT.cxx:351
JetForwardJvtToolBDT::tagTruth
StatusCode tagTruth(const xAOD::JetContainer *jets, const xAOD::JetContainer *truthJets)
Definition: JetForwardJvtToolBDT.cxx:444
lumiFormat.i
int i
Definition: lumiFormat.py:85
JetForwardJvtToolBDT::m_lclemprobKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_lclemprobKey
Definition: JetForwardJvtToolBDT.h:138
JetForwardJvtToolBDT::getFJVT
float getFJVT(const xAOD::Jet *jet, int pvind, const std::vector< TVector2 > &pileupMomenta) const
Definition: JetForwardJvtToolBDT.cxx:184
JetForwardJvtToolBDT::m_clemprobKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_clemprobKey
Definition: JetForwardJvtToolBDT.h:131
JetForwardJvtToolBDT::passMVfJVT
bool passMVfJVT(float mvfjvt, float pt, float eta) const
Definition: JetForwardJvtToolBDT.cxx:265
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
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
JetForwardJvtToolBDT::m_jetContainerName
Gaudi::Property< std::string > m_jetContainerName
Definition: JetForwardJvtToolBDT.h:123
JetForwardJvtToolBDT::m_wpFileIn
std::unique_ptr< TFile > m_wpFileIn
Definition: JetForwardJvtToolBDT.h:104
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
LHEF::Reader
Pythia8::Reader Reader
Definition: Prophecy4fMerger.cxx:11
JetForwardJvtToolBDT::m_lclwidthKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_lclwidthKey
Definition: JetForwardJvtToolBDT.h:136
JetForwardJvtToolBDT::m_clisoKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_clisoKey
Definition: JetForwardJvtToolBDT.h:130
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
JetForwardJvtToolBDT::m_forwardMaxPt
Gaudi::Property< double > m_forwardMaxPt
Definition: JetForwardJvtToolBDT.h:110
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
JetForwardJvtToolBDT::initialize
virtual StatusCode initialize() override
Dummy implementation of the initialisation function.
Definition: JetForwardJvtToolBDT.cxx:38
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
xAOD::VxType::PileUp
@ PileUp
Pile-up vertex.
Definition: TrackingPrimitives.h:574
PathResolver.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
JetForwardJvtToolBDT::m_isPUKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_isPUKey
Definition: JetForwardJvtToolBDT.h:147
JetForwardJvtToolBDT::m_caloClusterContainerKey
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_caloClusterContainerKey
Definition: JetForwardJvtToolBDT.h:143
JetForwardJvtToolBDT::m_jetScaleFactor
Gaudi::Property< double > m_jetScaleFactor
Definition: JetForwardJvtToolBDT.h:117
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:321
xAOD::score
@ score
Definition: TrackingPrimitives.h:514
JetForwardJvtToolBDT::m_MVreader
std::unique_ptr< TMVA::Reader > m_MVreader
Definition: JetForwardJvtToolBDT.h:105
JetForwardJvtToolBDT::m_cleKey
SG::WriteDecorHandleKey< xAOD::JetContainer > m_cleKey
Definition: JetForwardJvtToolBDT.h:132
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
JetForwardJvtToolBDT::m_wpFile
Gaudi::Property< std::string > m_wpFile
Definition: JetForwardJvtToolBDT.h:102
SG::WriteDecorHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
Base_Fragment.width
width
Definition: Sherpa_i/share/common/Base_Fragment.py:59
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
GeV
const double GeV
Definition: JetForwardJvtToolBDT.cxx:20
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
JetForwardJvtToolBDT::m_maxStochPt
Gaudi::Property< double > m_maxStochPt
Definition: JetForwardJvtToolBDT.h:116
JetForwardJvtToolBDT::m_jvtMomentName
Gaudi::Property< std::string > m_jvtMomentName
Definition: JetForwardJvtToolBDT.h:114
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:23
JetForwardJvtToolBDT::m_OP
Gaudi::Property< std::string > m_OP
Definition: JetForwardJvtToolBDT.h:118
JetForwardJvtToolBDT::m_centerDrptThresh
Gaudi::Property< double > m_centerDrptThresh
Definition: JetForwardJvtToolBDT.h:115
JetForwardJvtToolBDT::getMVfJVT
float getMVfJVT(const xAOD::Jet *jet, int pvind, const std::vector< TVector2 > &pileupMomenta) const
Definition: JetForwardJvtToolBDT.cxx:199
JetForwardJvtToolBDT::m_isAna
Gaudi::Property< bool > m_isAna
Definition: JetForwardJvtToolBDT.h:120
JetForwardJvtToolBDT::m_lcleKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_lcleKey
Definition: JetForwardJvtToolBDT.h:139
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
ConstAccessor.h
Helper class to provide constant type-safe access to aux data.
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
JetForwardJvtToolBDT::getPV
int getPV() const
Definition: JetForwardJvtToolBDT.cxx:428
collisions.reader
reader
read the goodrunslist xml file(s)
Definition: collisions.py:22
checker_macros.h
Define macros for attributes used to control the static checker.
JetForwardJvtToolBDT::forwardJet
bool forwardJet(const xAOD::Jet *jet) const
Definition: JetForwardJvtToolBDT.cxx:382
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:51
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:25
JetForwardJvtToolBDT::JetForwardJvtToolBDT
JetForwardJvtToolBDT(const std::string &name)
Constructor with parameters:
Definition: JetForwardJvtToolBDT.cxx:27
JetForwardJvtToolBDT::m_vertexContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexContainerKey
Definition: JetForwardJvtToolBDT.h:142
JetForwardJvtToolBDT::m_centerJvtThresh
Gaudi::Property< double > m_centerJvtThresh
Definition: JetForwardJvtToolBDT.h:113
xAOD::EventInfo_v1::actualInteractionsPerCrossing
float actualInteractionsPerCrossing() const
Average interactions per crossing for the current BCID - for in-time pile-up.
Definition: EventInfo_v1.cxx:380
JetForwardJvtToolBDT::m_MVconfig
Gaudi::Property< std::vector< std::string > > m_MVconfig
Definition: JetForwardJvtToolBDT.h:84
LArGeo::ATan2
GeoGenfun::FunctionNoop ATan2(GeoGenfun::GENFUNCTION y, GeoGenfun::GENFUNCTION x)
Definition: BarrelAuxFunctions.cxx:50
Generated on Thu Oct 30 2025 21:12:22 for ATLAS Offline Software by   doxygen 1.8.18