ATLAS Offline Software
MultivariateTagManager.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
16 
17 #include "JetTagTools/MultivariateTagManager.h"
18 #include "JetTagTools/BTagVariables.h"
19 #include "AthContainers/AuxElement.h"
20 
21 #include <fstream>
22 #include <sstream>
23 #include <algorithm>
24 #include <iostream>
25 #include <exception>
26 #include <limits> // check for NAN
27 #include <cmath> // NAN
28 
29 
30 namespace {
31  static_assert(std::numeric_limits<double>::has_quiet_NaN,
32  "no NaN defined, but we require one");
33  // int values use -1 for a placeholder,
34  const int INT_MISSING = -1;
35  double nan_if_placeholder(int);
36 }
37 
38 namespace Analysis {
39  MultivariateTagManager::MultivariateTagManager(const std::string& name, const std::string& n, const IInterface* p)
40  : base_class(name, n, p),
41  m_MultivariateTaggerHandleArray(this)
42  {
43  // List of the tagging tools to be used
44  declareProperty("MVTagToolList", m_MultivariateTaggerHandleArray);
45 
46  declareProperty("inputSV0SourceName", m_sv0_infosource = "SV0");
47  declareProperty("inputSV1SourceName", m_sv1_infosource = "SV1");
48  declareProperty("inputIP2DSourceName", m_ip2d_infosource = "IP2D");
49  declareProperty("inputIP3DSourceName", m_ip3d_infosource = "IP3D");
50  declareProperty("inputJFSourceName", m_jftNN_infosource = "JetFitter");
51  declareProperty("inputSoftMuonSourceName", m_softmuon_infosource = "SMT");
52  declareProperty("arbitraryAuxData", m_arbitrary_aux_data);
53  declareProperty("auxDataNameMap", m_aux_data_name_map);
54  }
55 
56  StatusCode MultivariateTagManager::initialize()
57  {
58 
59  if (m_MultivariateTaggerHandleArray.empty()) {
60  ATH_MSG_ERROR("MVTagToolList is empty");
61  return StatusCode::FAILURE;
62  }
63 
64  if ( m_MultivariateTaggerHandleArray.retrieve().isFailure() ) {
65  ATH_MSG_ERROR("#BTAG# Failed to retreive " << m_MultivariateTaggerHandleArray);
66  return StatusCode::FAILURE;
67  } else {
68  ATH_MSG_DEBUG("#BTAG# Retrieved " << m_MultivariateTaggerHandleArray);
69  }
70 
71  // get multivariate jet tagger
72  StatusCode sc = StatusCode::FAILURE;
73  for (auto& itr : m_MultivariateTaggerHandleArray) {
74  sc = itr.retrieve(); //initialize the tagger from the array
75  if(sc.isFailure()){
76  ATH_MSG_WARNING("Retrieving in the initialization of MultivariateTagManager failed.");
77  return StatusCode::FAILURE;
78  }
79  }
80 
81  ATH_MSG_INFO(" #BTAG# Initialization of MultivariateTagManager successfull" );
82  return StatusCode::SUCCESS;
83  }
84 
85  // _______________________________________________________________________
86  // MultivariateTagManager functions
87 
88  StatusCode MultivariateTagManager::tagJet(const xAOD::Vertex& priVtx,
89  const xAOD::Jet& jetToTag,
90  xAOD::BTagging& BTag,
91  const std::string &jetName) const
92  {
93  ATH_MSG_DEBUG("#BTAG# Jet author: " << jetName );
94 
95  if ( jetName.empty() ) {
96  ATH_MSG_WARNING(" #BTAG# Hypothesis or jetauthor is empty."
97  " No likelihood value given back. ");
98  }
99 
100  double jetpT = jetToTag.pt();
101  double jeteta = jetToTag.eta();
102 
103  // Fill Input Information
104  var_map inputs; // map of input information
105  inputs[btagvar::JET_ETA] = jeteta;
106  inputs[btagvar::JET_ABS_ETA] = std::fabs(jeteta);
107  inputs[btagvar::JET_PT] = jetpT;
108  fill_ip2d(inputs, BTag); // fill IP2D variables
109  fill_ip3d(inputs, BTag); // fill IP3D variables
110  fill_jetfitter(inputs, BTag); // fill JetFitter variables
111  fill_sv0(priVtx, inputs, BTag); // fill sv0 variables
112  fill_sv1(inputs, BTag); // fill sv1 variables
113  fill_trkSum(inputs,BTag);
114  fill_softmuon(inputs,BTag);
115 
116  fill_arbitrary_aux_data(inputs, BTag);
117 
118  ATH_MSG_DEBUG(" #BTAG# Retrieving of inputs successfull" );
119 
120  /* ----------------------------------------------------------------------------------- */
121  /* Call all the tag tools specified in m_MultivariateTaggerHandleArray */
122  /* ----------------------------------------------------------------------------------- */
123 
124  for (auto& itr: m_MultivariateTaggerHandleArray) {
125 
126  itr->assignProbability(&BTag, inputs, jetName);
127 
128  }
129 
130  ATH_MSG_DEBUG(" #BTAG# Retrieving of output successfull" );
131  return StatusCode::SUCCESS;
132  }
133 
134  // fill functions
135  void MultivariateTagManager::fill_softmuon(var_map& inputs, xAOD::BTagging& BTag) const {
136  float sm_mu_pt = NAN;
137  float sm_dR = NAN;
138  float sm_qOverPratio = NAN;
139  float sm_mombalsignif = NAN;
140  float sm_scatneighsignif = NAN;
141  float sm_pTrel = NAN;
142  float sm_mu_d0 = NAN;
143  float sm_mu_z0 = NAN;
144  float sm_ID_qOverP = NAN;
145 
146  BTag.variable<float>(m_softmuon_infosource, "mu_pt" , sm_mu_pt );
147  if(!std::isnan(sm_mu_pt) && sm_mu_pt>0){
148  BTag.variable<float>(m_softmuon_infosource, "dR" , sm_dR );
149  BTag.variable<float>(m_softmuon_infosource, "qOverPratio" , sm_qOverPratio );
150  BTag.variable<float>(m_softmuon_infosource, "mombalsignif" , sm_mombalsignif );
151  BTag.variable<float>(m_softmuon_infosource, "scatneighsignif" , sm_scatneighsignif);
152  BTag.variable<float>(m_softmuon_infosource, "pTrel" , sm_pTrel );
153  BTag.variable<float>(m_softmuon_infosource, "mu_d0" , sm_mu_d0 );
154  BTag.variable<float>(m_softmuon_infosource, "mu_z0" , sm_mu_z0 );
155  BTag.variable<float>(m_softmuon_infosource, "ID_qOverP" , sm_ID_qOverP );
156  }else{
157  sm_mu_pt= NAN;
158  }
159 
160  inputs[btagvar::SM_MU_PT] = sm_mu_pt;
161  inputs[btagvar::SM_DR] = sm_dR;
162  inputs[btagvar::SM_QOVERP] = sm_qOverPratio;
163  inputs[btagvar::SM_MOMBALSIG] = sm_mombalsignif;
164  inputs[btagvar::SM_SCATNEIGH] = sm_scatneighsignif;
165  inputs[btagvar::SM_PTREL] = sm_pTrel;
166  inputs[btagvar::SM_MU_D0] = sm_mu_d0;
167  inputs[btagvar::SM_MU_Z0] = sm_mu_z0;
168  inputs[btagvar::SM_ID_QOVERP] = sm_ID_qOverP;
169 
170  }
171 
172  void MultivariateTagManager::fill_trkSum(var_map& inputs, xAOD::BTagging& BTag) const {
173  float trkSum_ntrk = NAN;
174  float trkSum_sPt = NAN;
175  float trkSum_vPt = NAN;
176  float trkSum_vAbsEta =NAN;
177 
178  static const SG::AuxElement::ConstAccessor<unsigned> ntrkAcc ("trkSum_ntrk");
179  static const SG::AuxElement::ConstAccessor<float> SPtAcc ("trkSum_SPt");
180  trkSum_ntrk = ntrkAcc.isAvailable(BTag) ? ntrkAcc(BTag) : NAN;
181  trkSum_sPt = SPtAcc.isAvailable(BTag) ? SPtAcc(BTag): NAN;
182 
183  if (!std::isnan(trkSum_ntrk)){
184  static const SG::AuxElement::ConstAccessor<float> VPtAcc ("trkSum_VPt");
185  static const SG::AuxElement::ConstAccessor<float> VEtaAcc ("trkSum_VEta");
186  trkSum_vPt = VPtAcc.isAvailable(BTag) ? VPtAcc(BTag) : NAN;
187  trkSum_vAbsEta= VEtaAcc.isAvailable(BTag) ? VEtaAcc(BTag) : NAN;
188  }
189 
190  inputs[btagvar::TRKSUM_NTRK] = trkSum_ntrk;
191  inputs[btagvar::TRKSUM_SPT] = trkSum_sPt;
192  inputs[btagvar::TRKSUM_VPT] = trkSum_vPt;
193  inputs[btagvar::TRKSUM_ABSETA] = trkSum_vAbsEta;
194 
195  }
196 
197  void MultivariateTagManager::fill_jetfitter(var_map& inputs, xAOD::BTagging& BTag) const {
198  // default values
199  int jf_nvtx = INT_MISSING;
200  int jf_nvtx1t = INT_MISSING;
201  int jf_ntrkAtVx = INT_MISSING;
202  int jf_n2tv = INT_MISSING;
203  float jf_dphi = NAN;
204  float jf_deta = NAN;
205  float jf_dR = NAN;
206  float jf_dR_flight = NAN;
207  float jf_efrc = NAN;
208  float jf_mass = NAN;
209  float jf_mass_uncor = NAN;
210  float jf_sig3d = NAN;
211 
212  // check if we have vertices
213  int jf_nvtx_tmp(INT_MISSING), jf_nvtx1t_tmp(INT_MISSING);
214  bool jfitter_ok(false);
215  std::vector< ElementLink< xAOD::BTagVertexContainer > > jf_vertices;
216  BTag.variable<std::vector<ElementLink<xAOD::BTagVertexContainer> > >(m_jftNN_infosource, "JFvertices", jf_vertices);
217  if("JetFitter" == m_jftNN_infosource) {
218  BTag.taggerInfo(jf_nvtx_tmp, xAOD::BTagInfo::JetFitter_nVTX);
219  BTag.taggerInfo(jf_nvtx1t_tmp, xAOD::BTagInfo::JetFitter_nSingleTracks);
220  }
221  else {
222  BTag.variable<int>(m_jftNN_infosource, "nVTX", jf_nvtx_tmp );
223  BTag.variable<int>(m_jftNN_infosource, "nSingleTracks", jf_nvtx1t_tmp);
224  }
225 
226  if(!jf_vertices.empty() && jf_vertices[0].isValid() &&
227  (jf_nvtx_tmp > 0 || jf_nvtx1t_tmp > 0)) jfitter_ok = true;
228 
229  if(jfitter_ok) {
230  // Get values from the xAOD
231  if("JetFitter" == m_jftNN_infosource) { // check if JetFitter is known by the xAOD?
232  BTag.taggerInfo(jf_nvtx, xAOD::BTagInfo::JetFitter_nVTX);
233  BTag.taggerInfo(jf_nvtx1t, xAOD::BTagInfo::JetFitter_nSingleTracks);
234  BTag.taggerInfo(jf_ntrkAtVx, xAOD::BTagInfo::JetFitter_nTracksAtVtx);
235  BTag.taggerInfo(jf_n2tv, xAOD::BTagInfo::JetFitter_N2Tpair);
236  BTag.taggerInfo(jf_efrc, xAOD::BTagInfo::JetFitter_energyFraction);
237  BTag.taggerInfo(jf_mass, xAOD::BTagInfo::JetFitter_mass);
238  BTag.taggerInfo(jf_sig3d, xAOD::BTagInfo::JetFitter_significance3d);
239  BTag.taggerInfo(jf_dphi, xAOD::BTagInfo::JetFitter_deltaphi);
240  BTag.taggerInfo(jf_deta, xAOD::BTagInfo::JetFitter_deltaeta);
241  }
242  else { // get variables explicitely
243  BTag.variable<int>(m_jftNN_infosource, "nVTX", jf_nvtx);
244  BTag.variable<int>(m_jftNN_infosource, "nSingleTracks", jf_nvtx1t);
245  BTag.variable<int>(m_jftNN_infosource, "nTracksAtVtx", jf_ntrkAtVx);
246  BTag.variable<int>(m_jftNN_infosource, "N2Tpair", jf_n2tv);
247  BTag.variable<float>(m_jftNN_infosource, "energyFraction", jf_efrc);
248  BTag.variable<float>(m_jftNN_infosource, "mass", jf_mass);
249  BTag.variable<float>(m_jftNN_infosource, "significance3d", jf_sig3d);
250  BTag.variable<float>(m_jftNN_infosource, "deltaphi", jf_dphi);
251  BTag.variable<float>(m_jftNN_infosource, "deltaeta", jf_deta);
252  }
253 
254  // NOTE: no need to check for NAN here, it should do the right thing
255  // http://en.cppreference.com/w/cpp/numeric/math/hypot#Error_handling
256  jf_dR = std::hypot(jf_dphi,jf_deta);
257  //new jf variables
258  BTag.variable<float>(m_jftNN_infosource, "massUncorr" , jf_mass_uncor);
259  BTag.variable<float>(m_jftNN_infosource, "dRFlightDir", jf_dR_flight);
260  }
261  // add variables to input map
262  inputs[btagvar::JF_NVTX] = nan_if_placeholder(jf_nvtx);
263  inputs[btagvar::JF_NVTX1T] = nan_if_placeholder(jf_nvtx1t);
264  inputs[btagvar::JF_NTRKV] = nan_if_placeholder(jf_ntrkAtVx);
265  inputs[btagvar::JF_EFRC] = jf_efrc;
266  inputs[btagvar::JF_MASS] = jf_mass;
267  inputs[btagvar::JF_MASS_UNCOR] = jf_mass_uncor;
268  inputs[btagvar::JF_N2TV] = nan_if_placeholder(jf_n2tv);
269  inputs[btagvar::JF_SIG3D] = jf_sig3d;
270  inputs[btagvar::JF_DR] = jf_dR;
271  inputs[btagvar::JF_DR_FLIGHT]= jf_dR_flight;
272  inputs[btagvar::JF_DPHI] = jf_dphi;
273  inputs[btagvar::JF_DETA] = jf_deta;
274  }
275 
276 
277 
278  void MultivariateTagManager::fill_ip2d(var_map& inputs, xAOD::BTagging& BTag) const {
279  // default values
280  float ip2d_pb = NAN;
281  float ip2d_pc = NAN;
282  float ip2d_pu = NAN;
283 
284  float ip2 = NAN;
285  float ip2_c = NAN;
286  float ip2_cu= NAN;
287 
288  float ip2_nan = NAN;
289  float ip2_c_nan = NAN;
290  float ip2_cu_nan= NAN;
291 
292  std::vector<float> weightBofTracksIP2D;
293  BTag.variable<std::vector<float> >(m_ip2d_infosource, "weightBofTracks", weightBofTracksIP2D);
294  if(!weightBofTracksIP2D.empty()) {
295 
296  if( m_ip2d_infosource == "IP2D" ) {
297  ip2d_pb = BTag.IP2D_pb();
298  ip2d_pc = BTag.IP2D_pc();
299  ip2d_pu = BTag.IP2D_pu();
300  }
301  else {
302  BTag.variable<float>(m_ip2d_infosource, "pb", ip2d_pb);
303  BTag.variable<float>(m_ip2d_infosource, "pc", ip2d_pc);
304  BTag.variable<float>(m_ip2d_infosource, "pu", ip2d_pu);
305  }
306 
307  ip2 = BTag.calcLLR(ip2d_pb,ip2d_pu);
308  ip2_c = BTag.calcLLR(ip2d_pb,ip2d_pc);
309  ip2_cu = BTag.calcLLR(ip2d_pc,ip2d_pu);
310 
311  if(ip2d_pb<=0. or ip2d_pu<=0. or ip2d_pb==NAN or ip2d_pu==NAN) {
312  ip2_nan = NAN;
313  } else {
314  ip2_nan = log(ip2d_pb/ip2d_pu);
315  }
316 
317  if(ip2d_pb<=0. or ip2d_pc<=0. or ip2d_pb==NAN or ip2d_pc==NAN) {
318  ip2_c_nan = NAN;
319  } else {
320  ip2_c_nan = log(ip2d_pb/ip2d_pc);
321  }
322 
323  if(ip2d_pc<=0. or ip2d_pu<=0. or ip2d_pc==NAN or ip2d_pu==NAN) {
324  ip2_cu_nan = NAN;
325  } else {
326  ip2_cu_nan = log(ip2d_pc/ip2d_pu);
327  }
328  }
329 
330  // add variables to input map
331  inputs[btagvar::IP2D_PB] = ip2d_pb;
332  inputs[btagvar::IP2D_PC] = ip2d_pc;
333  inputs[btagvar::IP2D_PU] = ip2d_pu;
334  inputs[btagvar::IP2] = ip2;
335  inputs[btagvar::IP2_C] = ip2_c;
336  inputs[btagvar::IP2_CU] = ip2_cu;
337  inputs[btagvar::IP2_NAN] = ip2_nan;
338  inputs[btagvar::IP2_C_NAN] = ip2_c_nan;
339  inputs[btagvar::IP2_CU_NAN] = ip2_cu_nan;
340 
341  }
342 
343  void MultivariateTagManager::fill_ip3d(var_map& inputs, xAOD::BTagging& BTag) const {
344  // default values
345  float ip3d_pb = NAN;
346  float ip3d_pc = NAN;
347  float ip3d_pu = NAN;
348 
349  float ip3 = NAN;
350  float ip3_c = NAN;
351  float ip3_cu= NAN;
352 
353  float ip3_nan = NAN;
354  float ip3_c_nan = NAN;
355  float ip3_cu_nan = NAN;
356 
357  std::vector<float> weightBofTracksIP3D;
358  BTag.variable<std::vector<float> >(m_ip3d_infosource, "weightBofTracks", weightBofTracksIP3D);
359  if(!weightBofTracksIP3D.empty()) {
360  if( m_ip3d_infosource == "IP3D" ) {
361  ip3d_pb = BTag.IP3D_pb();
362  ip3d_pc = BTag.IP3D_pc();
363  ip3d_pu = BTag.IP3D_pu();
364  }
365  else {
366  BTag.variable<float>(m_ip3d_infosource, "pb", ip3d_pb);
367  BTag.variable<float>(m_ip3d_infosource, "pc", ip3d_pc);
368  BTag.variable<float>(m_ip3d_infosource, "pu", ip3d_pu);
369  }
370 
371  ip3 = BTag.calcLLR(ip3d_pb,ip3d_pu);
372  ip3_c = BTag.calcLLR(ip3d_pb,ip3d_pc);
373  ip3_cu = BTag.calcLLR(ip3d_pc,ip3d_pu);
374 
375  if(ip3d_pb<=0. or ip3d_pu<=0. or ip3d_pb==NAN or ip3d_pu==NAN) {
376  ip3_nan = NAN;
377  } else {
378  ip3_nan = log(ip3d_pb/ip3d_pu);
379  }
380 
381  if(ip3d_pb<=0. or ip3d_pc<=0. or ip3d_pb==NAN or ip3d_pc==NAN) {
382  ip3_c_nan = NAN;
383  } else {
384  ip3_c_nan = log(ip3d_pb/ip3d_pc);
385  }
386 
387  if(ip3d_pc<=0. or ip3d_pu<=0. or ip3d_pc==NAN or ip3d_pu==NAN) {
388  ip3_cu_nan = NAN;
389  } else {
390  ip3_cu_nan = log(ip3d_pc/ip3d_pu);
391  }
392  }
393 
394  // add variables to input map
395  inputs[btagvar::IP3D_PB] = ip3d_pb;
396  inputs[btagvar::IP3D_PC] = ip3d_pc;
397  inputs[btagvar::IP3D_PU] = ip3d_pu;
398  inputs[btagvar::IP3] = ip3;
399  inputs[btagvar::IP3_C] = ip3_c;
400  inputs[btagvar::IP3_CU] = ip3_cu;
401  inputs[btagvar::IP3_NAN] = ip3_nan;
402  inputs[btagvar::IP3_C_NAN] = ip3_c_nan;
403  inputs[btagvar::IP3_CU_NAN] = ip3_cu_nan;
404 
405  }
406 
407 
408  void MultivariateTagManager::fill_sv0(const xAOD::Vertex& priVtx,
409  var_map& inputs, xAOD::BTagging& BTag) const
410  {
411  // default values
412  int sv0_n2t = INT_MISSING;
413  int sv0_ntrkv = INT_MISSING;
414  float sv0_efrc = NAN;
415  float sv0_mass = NAN;
416  float sv0_radius = NAN;
417  float sv0_sig3d = NAN;
418  float sv0_pv_x = NAN, sv0_pv_y = NAN;
419 
420  // get vertex information
421  bool sv0_ok(false);
422  std::vector< ElementLink< xAOD::VertexContainer > > myVertices_SV0;
423  BTag.variable<std::vector<ElementLink<xAOD::VertexContainer> > >(m_sv1_infosource, "vertices", myVertices_SV0);
424 
425  if ( !myVertices_SV0.empty() && myVertices_SV0[0].isValid() ) {
426  // if we found a vertex, then sv0 is okay to use
427  sv0_ok = true;
428  }
429 
430  if (sv0_ok) {
431  if (m_sv0_infosource == "SV0") {
432  BTag.taggerInfo(sv0_mass, xAOD::BTagInfo::SV0_masssvx);
433  BTag.taggerInfo(sv0_efrc, xAOD::BTagInfo::SV0_efracsvx);
434  BTag.taggerInfo(sv0_n2t, xAOD::BTagInfo::SV0_N2Tpair);
435  BTag.taggerInfo(sv0_ntrkv, xAOD::BTagInfo::SV0_NGTinSvx);
436  }
437  else {
438  BTag.variable<float>(m_sv0_infosource, "masssvx", sv0_mass);
439  BTag.variable<float>(m_sv0_infosource, "efracsvx", sv0_efrc);
440  BTag.variable<int>(m_sv0_infosource, "N2Tpair", sv0_n2t);
441  BTag.variable<int>(m_sv0_infosource, "NGTinSvx", sv0_ntrkv);
442  }
443  BTag.variable<float>(m_sv0_infosource, "significance3D", sv0_sig3d);
444 
445  sv0_pv_x=priVtx.x();
446  sv0_pv_y=priVtx.y();
447  sv0_radius = sqrt(pow(sv0_pv_x,2)+pow(sv0_pv_y,2));
448  }
449 
450  // add variables to input map
451  inputs[btagvar::SV0_MASS] = sv0_mass;
452  inputs[btagvar::SV0_EFRC] = sv0_efrc;
453  inputs[btagvar::SV0_N2T] = nan_if_placeholder(sv0_n2t);
454  inputs[btagvar::SV0_NTRKV] = nan_if_placeholder(sv0_ntrkv);
455  inputs[btagvar::SV0_SIG3D] = sv0_sig3d;
456  inputs[btagvar::SV0_RADIUS] = sv0_radius;
457  }
458 
459 
460  void MultivariateTagManager::fill_sv1(var_map& inputs, xAOD::BTagging& BTag) const {
461  // default values
462  float sv1_pb = NAN, sv1_pc = NAN, sv1_pu = NAN;
463  float sv1 = NAN, sv1_c = NAN, sv1_cu = NAN;
464  float sv1_nan = NAN, sv1_c_nan = NAN, sv1_cu_nan = NAN;
465 
466  int sv1_n2t = INT_MISSING;
467  int sv1_ntrkv = INT_MISSING;
468  float sv1_efrc = NAN;
469  float sv1_mass = NAN;
470  float sv1_Lxy = NAN;
471  float sv1_L3d = NAN;
472  float sv1_sig3d = NAN;
473  float sv1_dR = NAN;
474  float sv1_distmatlay = NAN;
475 
476  // get vertex information
477  bool sv1_ok(false);
478  std::vector< ElementLink< xAOD::VertexContainer > > myVertices_SV1;
479  BTag.variable<std::vector<ElementLink<xAOD::VertexContainer> > >(m_sv1_infosource, "vertices", myVertices_SV1);
480  if ( !myVertices_SV1.empty() && myVertices_SV1[0].isValid() ) {
481  // if we found a vertex, then sv1 is okay to use
482  sv1_ok = true;
483  }
484 
485  if (sv1_ok) {
486  if (m_sv1_infosource == "SV1") {
487  sv1_pb=BTag.SV1_pb();
488  sv1_pu=BTag.SV1_pu();
489  sv1_pc=BTag.SV1_pc();
490 
491  BTag.taggerInfo(sv1_mass, xAOD::BTagInfo::SV1_masssvx);
492  BTag.taggerInfo(sv1_efrc, xAOD::BTagInfo::SV1_efracsvx);
493  BTag.taggerInfo(sv1_n2t, xAOD::BTagInfo::SV1_N2Tpair);
494  BTag.taggerInfo(sv1_ntrkv, xAOD::BTagInfo::SV1_NGTinSvx);
495  BTag.taggerInfo(sv1_sig3d, xAOD::BTagInfo::SV1_normdist);
496  }
497  else {
498  BTag.variable<float>(m_sv1_infosource, "pu", sv1_pu);
499  BTag.variable<float>(m_sv1_infosource, "pb", sv1_pb);
500  BTag.variable<float>(m_sv1_infosource, "pc", sv1_pc);
501 
502  BTag.variable<float>(m_sv1_infosource, "masssvx", sv1_mass);
503  BTag.variable<float>(m_sv1_infosource, "efracsvx", sv1_efrc);
504  BTag.variable<int>(m_sv1_infosource, "N2Tpair", sv1_n2t);
505  BTag.variable<int>(m_sv1_infosource, "NGTinSvx", sv1_ntrkv);
506  BTag.variable<float>(m_sv1_infosource, "normdist", sv1_sig3d);
507  }
508  BTag.variable<float>(m_sv1_infosource, "dstToMatLay" , sv1_distmatlay);
509  BTag.variable<float>(m_sv1_infosource, "deltaR", sv1_dR);
510  BTag.variable<float>(m_sv1_infosource, "Lxy", sv1_Lxy);
511  BTag.variable<float>(m_sv1_infosource, "L3d", sv1_L3d);
512 
513  sv1 = BTag.calcLLR(sv1_pb,sv1_pu);
514  sv1_c = BTag.calcLLR(sv1_pb,sv1_pc);
515  sv1_cu = BTag.calcLLR(sv1_pc,sv1_pu);
516 
517  if(sv1_pb<=0. or sv1_pu<=0. or sv1_pb==NAN or sv1_pu==NAN) {
518  sv1_nan = NAN;
519  } else {
520  sv1_nan = log(sv1_pb/sv1_pu);
521  }
522 
523  if(sv1_pb<=0. or sv1_pc<=0. or sv1_pb==NAN or sv1_pc==NAN) {
524  sv1_c_nan = NAN;
525  } else {
526  sv1_c_nan = log(sv1_pb/sv1_pc);
527  }
528 
529  if(sv1_pc<=0. or sv1_pu<=0. or sv1_pc==NAN or sv1_pu==NAN) {
530  sv1_cu_nan = NAN;
531  } else {
532  sv1_cu_nan = log(sv1_pc/sv1_pu);
533  }
534  }
535 
536  // add variables to input map
537  inputs[btagvar::SV1_PB] = sv1_pb;
538  inputs[btagvar::SV1_PC] = sv1_pc;
539  inputs[btagvar::SV1_PU] = sv1_pu;
540  inputs[btagvar::SV1] = sv1;
541  inputs[btagvar::SV1_C] = sv1_c;
542  inputs[btagvar::SV1_CU] = sv1_cu;
543  inputs[btagvar::SV1_NAN] = sv1_nan;
544  inputs[btagvar::SV1_C_NAN] = sv1_c_nan;
545  inputs[btagvar::SV1_CU_NAN] = sv1_cu_nan;
546 
547  inputs[btagvar::SV1_EFRC] = sv1_efrc;
548  inputs[btagvar::SV1_MASS] = sv1_mass;
549  inputs[btagvar::SV1_N2T] = nan_if_placeholder(sv1_n2t);
550  inputs[btagvar::SV1_NTRKV] = nan_if_placeholder(sv1_ntrkv);
551  inputs[btagvar::SV1_LXY] = sv1_Lxy;
552  inputs[btagvar::SV1_L3D] = sv1_L3d;
553  inputs[btagvar::SV1_SIG3D] = sv1_sig3d;
554  inputs[btagvar::SV1_DR] = sv1_dR;
555  inputs[btagvar::SV1_DISTMATLAY] = sv1_distmatlay;
556  }
557 
558  void MultivariateTagManager::fill_arbitrary_aux_data(
559  var_map& inputs, xAOD::BTagging& BTag) const {
560 
561  for (const auto& raw_key: m_arbitrary_aux_data) {
562  auto key = raw_key;
563  if (m_aux_data_name_map.count(raw_key)) {
564  key = m_aux_data_name_map.at(raw_key);
565  }
566  // note: we should extend this to data types beyond float at
567  // some point
568  std::string valid_key = key + "IsValid";
569  SG::AuxElement::ConstAccessor<float> keyAcc (key);
570  SG::AuxElement::ConstAccessor<float> valid_keyAcc (valid_key);
571  if ( ! keyAcc.isAvailable(BTag) ) {
572  ATH_MSG_WARNING("aux data '" + key + "' is missing,"
573  " tagger inputs may be incomplete");
574  } else if (!valid_keyAcc.isAvailable(BTag)) {
575  ATH_MSG_WARNING("no key '" + valid_key + "' found, invalid inputs"
576  " may be interperated incorrectly");
577  inputs[key] = keyAcc(BTag);
578  } else if (!valid_keyAcc(BTag)) {
579  inputs[key] = NAN;
580  } else {
581  inputs[key] = keyAcc(BTag);
582  }
583  }
584 
585  }
586 
587 
588 } // end vp namespace
589 
590 namespace {
591  double nan_if_placeholder(int in) {
592  if (in == INT_MISSING) return NAN;
593  return in;
594  }
595 }
596 
597 // LocalWords: vertices
xAOD::JetFitter_deltaeta
@ JetFitter_deltaeta
JetFitter : Delta eta between jet and momentum sum of all tracks associated with displaced vertices r...
Definition: BTaggingEnums.h:56
xAOD::Vertex_v1::x
float x() const
Returns the x position.
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Analysis::MultivariateTagManager::m_sv0_infosource
std::string m_sv0_infosource
Definition: MultivariateTagManager.h:75
Analysis::MultivariateTagManager::m_aux_data_name_map
std::map< std::string, std::string > m_aux_data_name_map
Definition: MultivariateTagManager.h:82
xAOD::JetFitter_nSingleTracks
@ JetFitter_nSingleTracks
JetFitter : Number of single tracks.
Definition: BTaggingEnums.h:46
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
xAOD::SV1_N2Tpair
@ SV1_N2Tpair
SV1 : Number of 2-track pairs.
Definition: BTaggingEnums.h:35
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:54
Analysis::MultivariateTagManager::fill_sv0
void fill_sv0(const xAOD::Vertex &priVtx, var_map &inputs, xAOD::BTagging &BTag) const
Definition: MultivariateTagManager.cxx:408
xAOD::SV1_normdist
@ SV1_normdist
SV1 : 3D vertex significance.
Definition: BTaggingEnums.h:41
postInclude.inputs
inputs
Definition: postInclude.SortInput.py:15
MultivariateTagManager.h
Analysis::MultivariateTagManager::fill_arbitrary_aux_data
void fill_arbitrary_aux_data(var_map &inputs, xAOD::BTagging &BTag) const
Definition: MultivariateTagManager.cxx:558
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Analysis::MultivariateTagManager::fill_jetfitter
void fill_jetfitter(var_map &inputs, xAOD::BTagging &BTag) const
Definition: MultivariateTagManager.cxx:197
xAOD::JetFitter_energyFraction
@ JetFitter_energyFraction
JetFitter : Jet efrac.
Definition: BTaggingEnums.h:52
xAOD::JetFitter_nVTX
@ JetFitter_nVTX
JetFitter : Number of vertices.
Definition: BTaggingEnums.h:44
Analysis::MultivariateTagManager::fill_softmuon
void fill_softmuon(var_map &inputs, xAOD::BTagging &BTag) const
Definition: MultivariateTagManager.cxx:135
Analysis::MultivariateTagManager::m_arbitrary_aux_data
std::vector< std::string > m_arbitrary_aux_data
Definition: MultivariateTagManager.h:81
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
beamspotman.n
n
Definition: beamspotman.py:731
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
xAOD::SV0_NGTinSvx
@ SV0_NGTinSvx
SV0 : Number of good tracks in vertex.
Definition: BTaggingEnums.h:20
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Analysis::MultivariateTagManager::fill_sv1
void fill_sv1(var_map &inputs, xAOD::BTagging &BTag) const
Definition: MultivariateTagManager.cxx:460
Analysis::MultivariateTagManager::tagJet
virtual StatusCode tagJet(const xAOD::Vertex &priVtx, const xAOD::Jet &jetToTag, xAOD::BTagging &BTag, const std::string &jetName) const override
Definition: MultivariateTagManager.cxx:88
xAOD::JetFitter_mass
@ JetFitter_mass
JetFitter : Jet mass.
Definition: BTaggingEnums.h:50
xAOD::JetFitter_nTracksAtVtx
@ JetFitter_nTracksAtVtx
JetFitter : Number of tracks at vertex.
Definition: BTaggingEnums.h:48
xAOD::SV1_efracsvx
@ SV1_efracsvx
SV1 : energy fraction.
Definition: BTaggingEnums.h:39
xAOD::SV0_N2Tpair
@ SV0_N2Tpair
SV0 : Number of 2-track pairs.
Definition: BTaggingEnums.h:22
Analysis::MultivariateTagManager::m_softmuon_infosource
std::string m_softmuon_infosource
Definition: MultivariateTagManager.h:78
xAOD::BTagging_v1
Definition: BTagging_v1.h:39
Analysis::MultivariateTagManager::m_ip3d_infosource
std::string m_ip3d_infosource
Definition: MultivariateTagManager.h:74
xAOD::SV0_efracsvx
@ SV0_efracsvx
SV0 : energy fraction.
Definition: BTaggingEnums.h:26
xAOD::Jet_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: Jet_v1.cxx:49
xAOD::JetFitter_significance3d
@ JetFitter_significance3d
JetFitter : 3D vertex significance.
Definition: BTaggingEnums.h:54
xAOD::JetFitter_N2Tpair
@ JetFitter_N2Tpair
JetFitter : Number of 2-track pairs.
Definition: BTaggingEnums.h:60
Analysis::MultivariateTagManager::m_jftNN_infosource
std::string m_jftNN_infosource
Definition: MultivariateTagManager.h:77
xAOD::SV1_NGTinSvx
@ SV1_NGTinSvx
SV1 : Number of good tracks in vertex.
Definition: BTaggingEnums.h:33
Analysis
The namespace of all packages in PhysicsAnalysis/JetTagging.
Definition: BTaggingCnvAlg.h:20
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
Analysis::MultivariateTagManager::m_MultivariateTaggerHandleArray
ToolHandleArray< IMultivariateJetTagger > m_MultivariateTaggerHandleArray
Definition: MultivariateTagManager.h:84
BTagVariables.h
Analysis::MultivariateTagManager::initialize
virtual StatusCode initialize() override
Definition: MultivariateTagManager.cxx:56
Analysis::MultivariateTagManager::fill_ip3d
void fill_ip3d(var_map &inputs, xAOD::BTagging &BTag) const
Definition: MultivariateTagManager.cxx:343
Analysis::MultivariateTagManager::MultivariateTagManager
MultivariateTagManager(const std::string &, const std::string &, const IInterface *)
Definition: MultivariateTagManager.cxx:39
Analysis::MultivariateTagManager::var_map
std::map< std::string, double > var_map
Definition: MultivariateTagManager.h:58
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Analysis::MultivariateTagManager::m_sv1_infosource
std::string m_sv1_infosource
Definition: MultivariateTagManager.h:76
Analysis::MultivariateTagManager::m_ip2d_infosource
std::string m_ip2d_infosource
Definition: MultivariateTagManager.h:73
xAOD::Vertex_v1::y
float y() const
Returns the y position.
xAOD::SV0_masssvx
@ SV0_masssvx
SV0 : vertex mass.
Definition: BTaggingEnums.h:24
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
xAOD::JetFitter_deltaphi
@ JetFitter_deltaphi
JetFitter : Delta phi between jet and momentum sum of all tracks associated with displaced vertices r...
Definition: BTaggingEnums.h:58
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
Analysis::MultivariateTagManager::fill_ip2d
void fill_ip2d(var_map &inputs, xAOD::BTagging &BTag) const
Definition: MultivariateTagManager.cxx:278
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
xAODType::BTag
@ BTag
The object is a b-tagging object.
Definition: ObjectType.h:60
xAOD::Jet_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
Definition: Jet_v1.cxx:44
Analysis::MultivariateTagManager::fill_trkSum
void fill_trkSum(var_map &inputs, xAOD::BTagging &BTag) const
Definition: MultivariateTagManager.cxx:172
AuxElement.h
Base class for elements of a container that can have aux data.
xAOD::SV1_masssvx
@ SV1_masssvx
SV1 : vertex mass.
Definition: BTaggingEnums.h:37
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Thu Jul 4 2024 21:22:26 for ATLAS Offline Software by   doxygen 1.8.18