ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
DiTauRecTools::DiTauIDVarCalculator Class Referenceabstract

#include <DiTauIDVarCalculator.h>

Inheritance diagram for DiTauRecTools::DiTauIDVarCalculator:
Collaboration diagram for DiTauRecTools::DiTauIDVarCalculator:

Public Member Functions

virtual void print () const =0
 Print the state of the tool. More...
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

virtual StatusCode initialize () override
 Dummy implementation of the initialisation function. More...
 
virtual StatusCode calculateIDVariables (const xAOD::DiTauJet &xDiTau)
 
virtual StatusCode execute (const xAOD::DiTauJet &xDiTau) override
 Declare the interface that the class provides. More...
 
float ditau_pt (const xAOD::DiTauJet &xDiTau) const
 
float f_core (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
float f_subjet (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
float f_subjets (const xAOD::DiTauJet &xDiTau) const
 
float f_track (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
float R_max (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
int n_tracks (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
int n_othertrack (const xAOD::DiTauJet &xDiTau) const
 
float R_track (const xAOD::DiTauJet &xDiTau) const
 
float R_track_all (const xAOD::DiTauJet &xDiTau) const
 
float R_track_core (const xAOD::DiTauJet &xDiTau) const
 
float R_isotrack (const xAOD::DiTauJet &xDiTau) const
 
float R_core (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
float R_tracks (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
float mass_track (const xAOD::DiTauJet &xDiTau) const
 
float mass_track_core (const xAOD::DiTauJet &xDiTau) const
 
float mass_core (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
float mass_track_all (const xAOD::DiTauJet &xDiTau) const
 
float mass_tracks (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
float E_frac (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
float R_subjets (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
float d0_leadtrack (const xAOD::DiTauJet &xDiTau, int iSubjet) const
 
float f_isotracks (const xAOD::DiTauJet &xDiTau) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

static float n_subjets (const xAOD::DiTauJet &xDiTau)
 
static int n_track (const xAOD::DiTauJet &xDiTau)
 
static int n_isotrack (const xAOD::DiTauJet &xDiTau)
 
static StatusCode decorNtracks (const xAOD::DiTauJet &xDiTau)
 

Private Attributes

float m_dDefault
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 40 of file DiTauIDVarCalculator.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

◆ calculateIDVariables()

StatusCode DiTauIDVarCalculator::calculateIDVariables ( const xAOD::DiTauJet &  xDiTau)
privatevirtual

Definition at line 65 of file DiTauIDVarCalculator.cxx.

65  {
66  return execute(xDiTau);
67 }

◆ d0_leadtrack()

float DiTauIDVarCalculator::d0_leadtrack ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 940 of file DiTauIDVarCalculator.cxx.

941 {
942  double pt_leadtrk = 0;
943  double d0 = m_dDefault;
944  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
945  if (!trackLinksAcc.isAvailable(xDiTau) )
946  {
947  ATH_MSG_WARNING("Track links not available");
948  }
949 
950  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
951  if ( iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
952  return m_dDefault;
953  }
954 
955  TLorentzVector tlvSubjet;
956  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(iSubjet),
957  xDiTau.subjetEta(iSubjet),
958  xDiTau.subjetPhi(iSubjet),
959  xDiTau.subjetE(iSubjet) );
960 
961  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
962 
963  TLorentzVector tlvTrack;
964 
965  static const SG::ConstAccessor<float> R_coreAcc("R_core");
966  for (auto &xTrack: xTracks)
967  {
968  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
969  (*xTrack)->eta(),
970  (*xTrack)->phi(),
971  (*xTrack)->e() );
972 
973  if (tlvTrack.DeltaR(tlvSubjet) < R_coreAcc(xDiTau))
974  {
975  if (tlvTrack.Pt() > pt_leadtrk)
976  {
977  pt_leadtrk = tlvTrack.Pt();
978  d0 = (*xTrack)->d0();
979  }
980  }
981  }
982  return d0;
983 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ decorNtracks()

StatusCode DiTauIDVarCalculator::decorNtracks ( const xAOD::DiTauJet &  xDiTau)
staticprivate

Definition at line 1013 of file DiTauIDVarCalculator.cxx.

1014 {
1015  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
1016  if (!trackLinksAcc.isAvailable(xDiTau) )
1017  {
1018  Warning("decorNtracks()", "Track links not available.");
1019  return StatusCode::FAILURE;
1020  }
1021 
1022  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
1023  int nSubjets = n_subjetsAcc(xDiTau);
1024 
1025  static const SG::ConstAccessor<float> R_subjetAcc("R_subjet");
1026  float Rsubjet = R_subjetAcc(xDiTau);
1027  std::vector<int> nTracks(nSubjets, 0);
1028 
1029  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
1030  for (const auto &xTrack: xTracks)
1031  {
1032  double dRmin = 1111;
1033  double itrmin = -1;
1034 
1035  for (int i=0; i<nSubjets; ++i)
1036  {
1037  TLorentzVector tlvSubjet = TLorentzVector();
1038  tlvSubjet.SetPtEtaPhiE(xDiTau.subjetPt(i),
1039  xDiTau.subjetEta(i),
1040  xDiTau.subjetPhi(i),
1041  xDiTau.subjetE(i));
1042  double dR = tlvSubjet.DeltaR((*xTrack)->p4());
1043 
1044 
1045  if ((dR < Rsubjet) && (dR < dRmin))
1046  {
1047  dRmin = dR;
1048  itrmin = i;
1049  }
1050  } // loop over subjets
1051  if (itrmin > -1) nTracks[itrmin]++;
1052  } // loop over tracks
1053 
1054  static const SG::Decorator< std::vector<int> > n_tracksDec("n_tracks");
1055  n_tracksDec(xDiTau) = nTracks;
1056 
1057  return StatusCode::SUCCESS;
1058 }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ ditau_pt()

float DiTauIDVarCalculator::ditau_pt ( const xAOD::DiTauJet &  xDiTau) const
private

Definition at line 170 of file DiTauIDVarCalculator.cxx.

171 {
172  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
173  if (n_subjetsAcc(xDiTau) < 2 ) {
174  return m_dDefault;
175  }
176 
177  return xDiTau.subjetPt(0)+xDiTau.subjetPt(1);
178 }

◆ E_frac()

float DiTauIDVarCalculator::E_frac ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 900 of file DiTauIDVarCalculator.cxx.

901 {
902  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
903  if ( iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
904  return m_dDefault;
905  }
906 
907  return xDiTau.subjetE(iSubjet) / xDiTau.subjetE(0);
908 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode DiTauIDVarCalculator::execute ( const xAOD::DiTauJet &  xDiTau)
overrideprivatevirtual

Declare the interface that the class provides.

Implements DiTauRecTools::IDiTauToolBase.

Definition at line 69 of file DiTauIDVarCalculator.cxx.

70 {
71 
72  ATH_MSG_DEBUG("Calculate DiTau ID variables");
73 
74  static const SG::Decorator< int > n_subjetsDec("n_subjets");
75  n_subjetsDec(xDiTau) = n_subjets(xDiTau);
76  ATH_CHECK( decorNtracks(xDiTau) );
77 
78  static const SG::Decorator< float > ditau_ptDec("ditau_pt");
79  static const SG::Decorator< float > f_core_leadDec("f_core_lead");
80  static const SG::Decorator< float > f_core_sublDec("f_core_subl");
81  static const SG::Decorator< float > f_subjet_leadDec("f_subjet_lead");
82  static const SG::Decorator< float > f_subjet_sublDec("f_subjet_subl");
83  static const SG::Decorator< float > f_subjetsDec("f_subjets");
84  static const SG::Decorator< float > f_track_leadDec("f_track_lead");
85  static const SG::Decorator< float > f_track_sublDec("f_track_subl");
86  static const SG::Decorator< float > R_max_leadDec("R_max_lead");
87  static const SG::Decorator< float > R_max_sublDec("R_max_subl");
88  static const SG::Decorator< int > n_trackDec("n_track");
89  static const SG::Decorator< int > n_tracks_leadDec("n_tracks_lead");
90  static const SG::Decorator< int > n_tracks_sublDec("n_tracks_subl");
91  static const SG::Decorator< int > n_isotrackDec("n_isotrack");
92  static const SG::Decorator< float > R_trackDec("R_track");
93  static const SG::Decorator< float > R_track_coreDec("R_track_core");
94  static const SG::Decorator< float > R_track_allDec("R_track_all");
95  static const SG::Decorator< float > R_isotrackDec("R_isotrack");
96  static const SG::Decorator< float > R_core_leadDec("R_core_lead");
97  static const SG::Decorator< float > R_core_sublDec("R_core_subl");
98  static const SG::Decorator< float > R_tracks_leadDec("R_tracks_lead");
99  static const SG::Decorator< float > R_tracks_sublDec("R_tracks_subl");
100  static const SG::Decorator< float > M_trackDec("m_track");
101  static const SG::Decorator< float > M_track_coreDec("m_track_core");
102  static const SG::Decorator< float > M_core_leadDec("m_core_lead");
103  static const SG::Decorator< float > M_core_sublDec("m_core_subl");
104  static const SG::Decorator< float > M_track_allDec("m_track_all");
105  static const SG::Decorator< float > M_tracks_leadDec("m_tracks_lead");
106  static const SG::Decorator< float > M_tracks_sublDec("m_tracks_subl");
107  static const SG::Decorator< float > E_frac_sublDec("E_frac_subl");
108  static const SG::Decorator< float > E_frac_subsublDec("E_frac_subsubl");
109  static const SG::Decorator< float > R_subjets_sublDec("R_subjets_subl");
110  static const SG::Decorator< float > R_subjets_subsublDec("R_subjets_subsubl");
111  static const SG::Decorator< float > d0_leadtrack_leadDec("d0_leadtrack_lead");
112  static const SG::Decorator< float > d0_leadtrack_sublDec("d0_leadtrack_subl");
113  static const SG::Decorator< float > f_isotracksDec("f_isotracks");
114 
115  ditau_ptDec(xDiTau) = ditau_pt(xDiTau);
116  f_core_leadDec(xDiTau) = f_core(xDiTau, 0);
117  f_core_sublDec(xDiTau) = f_core(xDiTau, 1);
118  f_subjet_leadDec(xDiTau) = f_subjet(xDiTau, 0);
119  f_subjet_sublDec(xDiTau) = f_subjet(xDiTau, 1);
120  f_subjetsDec(xDiTau) = f_subjets(xDiTau);
121  f_track_leadDec(xDiTau) = f_track(xDiTau, 0);
122  f_track_sublDec(xDiTau) = f_track(xDiTau, 1);
123  R_max_leadDec(xDiTau) = R_max(xDiTau, 0);
124  R_max_sublDec(xDiTau) = R_max(xDiTau, 1);
125  n_trackDec(xDiTau) = n_track(xDiTau);
126  n_tracks_leadDec(xDiTau) = n_tracks(xDiTau, 0);
127  n_tracks_sublDec(xDiTau) = n_tracks(xDiTau, 1);
128  n_isotrackDec(xDiTau) = n_isotrack(xDiTau);
129  R_trackDec(xDiTau) = R_track(xDiTau);
130  R_track_coreDec(xDiTau) = R_track_core(xDiTau);
131  R_track_allDec(xDiTau) = R_track_all(xDiTau);
132  R_isotrackDec(xDiTau) = R_isotrack(xDiTau);
133  R_core_leadDec(xDiTau) = R_core(xDiTau, 0);
134  R_core_sublDec(xDiTau) = R_core(xDiTau, 1);
135  R_tracks_leadDec(xDiTau) = R_tracks(xDiTau, 0);
136  R_tracks_sublDec(xDiTau) = R_tracks(xDiTau, 1);
137  M_trackDec(xDiTau) = mass_track(xDiTau);
138  M_track_coreDec(xDiTau) = mass_track_core(xDiTau);
139  M_core_leadDec(xDiTau) = mass_core(xDiTau, 0);
140  M_core_sublDec(xDiTau) = mass_core(xDiTau, 1);
141  M_track_allDec(xDiTau) = mass_track_all(xDiTau);
142  M_tracks_leadDec(xDiTau) = mass_tracks(xDiTau, 0);
143  M_tracks_sublDec(xDiTau) = mass_tracks(xDiTau, 1);
144  E_frac_sublDec(xDiTau) = E_frac(xDiTau,1);
145  E_frac_subsublDec(xDiTau) = E_frac(xDiTau, 2);
146  R_subjets_sublDec(xDiTau) = R_subjets(xDiTau, 1);
147  R_subjets_subsublDec(xDiTau) = R_subjets(xDiTau, 2);
148  d0_leadtrack_leadDec(xDiTau) = d0_leadtrack(xDiTau, 0);
149  d0_leadtrack_sublDec(xDiTau) = d0_leadtrack(xDiTau, 1);
150  f_isotracksDec(xDiTau) = f_isotracks(xDiTau);
151 
152  return StatusCode::SUCCESS;
153 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ f_core()

float DiTauIDVarCalculator::f_core ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 182 of file DiTauIDVarCalculator.cxx.

183 {
184  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
185  if (iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
186  return m_dDefault;
187  }
188 
189  return xDiTau.fCore(iSubjet);
190 }

◆ f_isotracks()

float DiTauIDVarCalculator::f_isotracks ( const xAOD::DiTauJet &  xDiTau) const
private

Definition at line 986 of file DiTauIDVarCalculator.cxx.

987 {
988  double iso_pt = 0;
989  static const SG::ConstAccessor<TrackParticleLinks_t> isoTrackLinksAcc("isoTrackLinks");
990  if (!isoTrackLinksAcc.isAvailable(xDiTau) )
991  {
992  ATH_MSG_WARNING("Track links not available");
993  }
994 
995  TrackParticleLinks_t xIsoTracks = xDiTau.isoTrackLinks();
996 
997  TLorentzVector tlvIsoTrack;
998 
999  for (const auto& xIsoTrack: xIsoTracks)
1000  {
1001  tlvIsoTrack.SetPtEtaPhiE( (*xIsoTrack)->pt(),
1002  (*xIsoTrack)->eta(),
1003  (*xIsoTrack)->phi(),
1004  (*xIsoTrack)->e() );
1005 
1006  iso_pt += tlvIsoTrack.Pt();
1007  }
1008 
1009  return iso_pt / xDiTau.pt();
1010 }

◆ f_subjet()

float DiTauIDVarCalculator::f_subjet ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 194 of file DiTauIDVarCalculator.cxx.

195 {
196  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
197  if (iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
198  return m_dDefault;
199  }
200 
201  return xDiTau.subjetPt(iSubjet) / xDiTau.pt();
202 }

◆ f_subjets()

float DiTauIDVarCalculator::f_subjets ( const xAOD::DiTauJet &  xDiTau) const
private

Definition at line 206 of file DiTauIDVarCalculator.cxx.

207 {
208  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
209  if (n_subjetsAcc(xDiTau) < 2 ) {
210  return m_dDefault;
211  }
212 
213  return (xDiTau.subjetPt(0) + xDiTau.subjetPt(1))/ xDiTau.pt();
214 }

◆ f_track()

float DiTauIDVarCalculator::f_track ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 218 of file DiTauIDVarCalculator.cxx.

219 {
220  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
221  if (iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
222  return m_dDefault;
223  }
224 
225  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
226  if (!trackLinksAcc.isAvailable(xDiTau) )
227  {
228  ATH_MSG_WARNING("Link not available");
229  }
230 
231  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
232 
233  TLorentzVector tlvSubjet;
234  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(iSubjet),
235  xDiTau.subjetEta(iSubjet),
236  xDiTau.subjetPhi(iSubjet),
237  xDiTau.subjetE(iSubjet) );
238 
239  TLorentzVector tlvTrack;
240  TLorentzVector tlvLeadTrack;
241  tlvLeadTrack.SetPtEtaPhiE( 0,0,0, 0);
242 
243  for (const auto &xTrack: xTracks)
244  {
245  if (!xTrack)
246  {
247  ATH_MSG_ERROR("Could not read Track");
248  continue;
249  }
250  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
251  (*xTrack)->eta(),
252  (*xTrack)->phi(),
253  (*xTrack)->e() );
254 
255  if ( tlvSubjet.DeltaR(tlvTrack) < 0.2 )
256  {
257  if (tlvLeadTrack.Pt() < tlvTrack.Pt())
258  {
259  tlvLeadTrack = tlvTrack;
260  }
261  }
262  }
263 
264  return tlvLeadTrack.Pt() / tlvSubjet.Pt();
265 }

◆ getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void *  ptr) const
inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getName
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

119  {
120 
121 #ifdef XAOD_STANDALONE
122  // In case we use @c xAOD::TEvent, we have a direct function call
123  // for this.
124  return evtStore()->event()->getKey( ptr );
125 #else
126  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
127  return ( proxy == nullptr ? 0 : proxy->sgkey() );
128 #endif // XAOD_STANDALONE
129  }

◆ getName()

const std::string & asg::AsgTool::getName ( const void *  ptr) const
inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getKey
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

106  {
107 
108 #ifdef XAOD_STANDALONE
109  // In case we use @c xAOD::TEvent, we have a direct function call
110  // for this.
111  return evtStore()->event()->getName( ptr );
112 #else
113  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
114  static const std::string dummy = "";
115  return ( proxy == nullptr ? dummy : proxy->name() );
116 #endif // XAOD_STANDALONE
117  }

◆ getProperty()

template<class T >
const T* asg::AsgTool::getProperty ( const std::string &  name) const
inherited

Get one of the tool's properties.

◆ initialize()

StatusCode DiTauIDVarCalculator::initialize ( )
overrideprivatevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 54 of file DiTauIDVarCalculator.cxx.

55 {
56  ATH_MSG_INFO( "Initializing DiTauIDVarCalculator" );
57 
58  return StatusCode::SUCCESS;
59 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ mass_core()

float DiTauIDVarCalculator::mass_core ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 723 of file DiTauIDVarCalculator.cxx.

724 {
725 
726  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
727  if (!trackLinksAcc.isAvailable(xDiTau) )
728  {
729  ATH_MSG_WARNING("Link not available");
730  }
731 
732  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
733  if ( iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
734  return m_dDefault;
735  }
736 
737  TLorentzVector tlvallTracks;
738 
739 
740  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
741 
742  TLorentzVector tlvSubjet;
743  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(iSubjet),
744  xDiTau.subjetEta(iSubjet),
745  xDiTau.subjetPhi(iSubjet),
746  xDiTau.subjetE(iSubjet) );
747 
748  TLorentzVector tlvTrack;
749 
750  static const SG::ConstAccessor<float> R_coreAcc("R_core");
751  for (const auto& xTrack: xTracks)
752  {
753  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
754  (*xTrack)->eta(),
755  (*xTrack)->phi(),
756  (*xTrack)->e() );
757  if ( tlvSubjet.DeltaR(tlvTrack) < R_coreAcc(xDiTau) )
758  {
759  //ATH_MSG_DEBUG("smaller");
760  tlvallTracks += tlvTrack;
761  }
762  }
763 
764  if (tlvallTracks.M() < 0)
765  {
766  return m_dDefault;
767  }
768 
769  return tlvallTracks.M();
770 }

◆ mass_track()

float DiTauIDVarCalculator::mass_track ( const xAOD::DiTauJet &  xDiTau) const
private

Definition at line 819 of file DiTauIDVarCalculator.cxx.

820 {
821 
822  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
823  if (!trackLinksAcc.isAvailable(xDiTau) )
824  {
825  ATH_MSG_WARNING("Link not available");
826  }
827 
828  TLorentzVector tlvallTracks;
829 
830  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
831 
832  TLorentzVector tlvTrack;
833 
834  for (const auto& xTrack: xTracks)
835  {
836  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
837  (*xTrack)->eta(),
838  (*xTrack)->phi(),
839  (*xTrack)->e() );
840 
841  tlvallTracks += tlvTrack;
842  }
843 
844  if (tlvallTracks.M() < 0)
845  {
846  return m_dDefault;
847  }
848  return tlvallTracks.M();
849 }

◆ mass_track_all()

float DiTauIDVarCalculator::mass_track_all ( const xAOD::DiTauJet &  xDiTau) const
private

Definition at line 851 of file DiTauIDVarCalculator.cxx.

852 {
853 
854  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
855  if (!trackLinksAcc.isAvailable(xDiTau) )
856  {
857  ATH_MSG_WARNING("Link not available");
858  }
859 
860  TLorentzVector tlvallTracks;
861 
862  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
863 
864  TLorentzVector tlvTrack;
865 
866  for (const auto& xTrack: xTracks)
867  {
868  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
869  (*xTrack)->eta(),
870  (*xTrack)->phi(),
871  (*xTrack)->e() );
872 
873  tlvallTracks += tlvTrack;
874  }
875 
876 
877  TrackParticleLinks_t xIsoTracks = xDiTau.isoTrackLinks();
878 
879  TLorentzVector tlvIsoTrack;
880 
881  for (const auto& xIsoTrack: xIsoTracks)
882  {
883  tlvIsoTrack.SetPtEtaPhiE( (*xIsoTrack)->pt(),
884  (*xIsoTrack)->eta(),
885  (*xIsoTrack)->phi(),
886  (*xIsoTrack)->e() );
887 
888  tlvallTracks += tlvIsoTrack;
889  }
890 
891  if (tlvallTracks.M() < 0)
892  {
893  return m_dDefault;
894  }
895 
896  return tlvallTracks.M();
897 }

◆ mass_track_core()

float DiTauIDVarCalculator::mass_track_core ( const xAOD::DiTauJet &  xDiTau) const
private

Definition at line 671 of file DiTauIDVarCalculator.cxx.

672 {
673 
674  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
675  if (!trackLinksAcc.isAvailable(xDiTau) )
676  {
677  ATH_MSG_WARNING("Link not available");
678  }
679 
680  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
681  if (n_subjetsAcc(xDiTau) < 2) {
682  return m_dDefault;
683  }
684 
685  TLorentzVector tlvallTracks;
686 
687  static const SG::ConstAccessor<float> R_coreAcc("R_core");
688  for (int i = 0; i<=1; i++)
689  {
690 
691  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
692 
693  TLorentzVector tlvSubjet;
694  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(i),
695  xDiTau.subjetEta(i),
696  xDiTau.subjetPhi(i),
697  xDiTau.subjetE(i) );
698 
699  TLorentzVector tlvTrack;
700 
701  for (const auto& xTrack: xTracks)
702  {
703  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
704  (*xTrack)->eta(),
705  (*xTrack)->phi(),
706  (*xTrack)->e() );
707  if ( tlvSubjet.DeltaR(tlvTrack) < R_coreAcc(xDiTau) )
708  {
709  //ATH_MSG_DEBUG("smaller");
710  tlvallTracks += tlvTrack;
711  }
712  }
713  }
714  if (tlvallTracks.M() < 0)
715  {
716  return m_dDefault;
717  }
718 
719  return tlvallTracks.M();
720 }

◆ mass_tracks()

float DiTauIDVarCalculator::mass_tracks ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 773 of file DiTauIDVarCalculator.cxx.

774 {
775 
776  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
777  if (!trackLinksAcc.isAvailable(xDiTau) )
778  {
779  ATH_MSG_WARNING("Link not available");
780  }
781 
782  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
783  if ( iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
784  return m_dDefault;
785  }
786 
787  TLorentzVector tlvallTracks;
788 
789  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
790 
791  TLorentzVector tlvSubjet;
792  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(iSubjet),
793  xDiTau.subjetEta(iSubjet),
794  xDiTau.subjetPhi(iSubjet),
795  xDiTau.subjetE(iSubjet) );
796 
797  TLorentzVector tlvTrack;
798 
799  for (const auto& xTrack: xTracks)
800  {
801  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
802  (*xTrack)->eta(),
803  (*xTrack)->phi(),
804  (*xTrack)->e() );
805  if ( tlvSubjet.DeltaR(tlvTrack) < 0.2 )
806  {
807  tlvallTracks += tlvTrack;
808  }
809  }
810 
811  if (tlvallTracks.M() < 0)
812  {
813  return m_dDefault;
814  }
815 
816  return tlvallTracks.M();
817 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const
inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns
The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

101  {
102 
103  return MSG::name( msg().level() );
104  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ n_isotrack()

int DiTauIDVarCalculator::n_isotrack ( const xAOD::DiTauJet &  xDiTau)
staticprivate

Definition at line 361 of file DiTauIDVarCalculator.cxx.

362 {
363  return xDiTau.nIsoTracks();
364 }

◆ n_othertrack()

int DiTauRecTools::DiTauIDVarCalculator::n_othertrack ( const xAOD::DiTauJet &  xDiTau) const
private

◆ n_subjets()

float DiTauIDVarCalculator::n_subjets ( const xAOD::DiTauJet &  xDiTau)
staticprivate

Definition at line 158 of file DiTauIDVarCalculator.cxx.

159 {
160  int nSubjet = 0;
161  while (xDiTau.subjetPt(nSubjet) > 0. )
162  {
163  nSubjet++;
164  }
165 
166  return nSubjet;
167 }

◆ n_track()

int DiTauIDVarCalculator::n_track ( const xAOD::DiTauJet &  xDiTau)
staticprivate

Definition at line 309 of file DiTauIDVarCalculator.cxx.

310 {
311  return xDiTau.nTracks();
312 }

◆ n_tracks()

int DiTauIDVarCalculator::n_tracks ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 315 of file DiTauIDVarCalculator.cxx.

316 {
317  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
318  if (iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
319  return m_dDefault;
320  }
321 
322  static const SG::ConstAccessor<std::vector<int> > n_tracksAcc("n_tracks");
323  if (!n_tracksAcc.isAvailable(xDiTau))
324  {
325  ATH_MSG_DEBUG("n_tracks decoration not available. Try with track links.");
326 
327  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
328  if (!trackLinksAcc.isAvailable(xDiTau) )
329  {
330  ATH_MSG_WARNING("Track links not available. Return 0.");
331  return (int)m_dDefault;
332  }
333 
334  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
335 
336  TLorentzVector tlvSubjet;
337  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(iSubjet),
338  xDiTau.subjetEta(iSubjet),
339  xDiTau.subjetPhi(iSubjet),
340  xDiTau.subjetE(iSubjet) );
341 
342  TLorentzVector tlvTrack;
343  int nTracks = 0;
344  for (const auto &xTrack: xTracks)
345  {
346  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
347  (*xTrack)->eta(),
348  (*xTrack)->phi(),
349  (*xTrack)->e() );
350  if ( tlvSubjet.DeltaR(tlvTrack) < 0.2 ) nTracks++;
351  }
352 
353  return nTracks;
354  }
355 
356  return n_tracksAcc(xDiTau).at(iSubjet);
357 
358 }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ print() [1/2]

void asg::AsgTool::print ( ) const
virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

131  {
132 
133  ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134  return;
135  }

◆ print() [2/2]

virtual void asg::IAsgTool::print ( ) const
pure virtualinherited

Print the state of the tool.

Implemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, asg::AsgTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

◆ R_core()

float DiTauIDVarCalculator::R_core ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 417 of file DiTauIDVarCalculator.cxx.

418 {
419  double R_sum = 0;
420  double pt = 0;
421 
422  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
423  if (!trackLinksAcc.isAvailable(xDiTau) )
424  {
425  ATH_MSG_WARNING("Link not available");
426  }
427  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
428  if (iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
429  return m_dDefault;
430  }
431 
432  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
433 
434  TLorentzVector tlvSubjet;
435  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(iSubjet),
436  xDiTau.subjetEta(iSubjet),
437  xDiTau.subjetPhi(iSubjet),
438  xDiTau.subjetE(iSubjet) );
439 
440  TLorentzVector tlvTrack;
441 
442  static const SG::ConstAccessor<float> R_coreAcc("R_core");
443  for (const auto& xTrack: xTracks)
444  {
445  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
446  (*xTrack)->eta(),
447  (*xTrack)->phi(),
448  (*xTrack)->e() );
449 
450  if ( tlvSubjet.DeltaR(tlvTrack) < R_coreAcc(xDiTau) )
451  {
452  R_sum += tlvSubjet.DeltaR(tlvTrack)*tlvTrack.Pt();
453  pt += tlvTrack.Pt();
454  }
455  }
456 
457  if (pt == 0)
458  {
459  return m_dDefault;
460  }
461 
462  return R_sum / pt;
463 }

◆ R_isotrack()

float DiTauIDVarCalculator::R_isotrack ( const xAOD::DiTauJet &  xDiTau) const
private

Definition at line 618 of file DiTauIDVarCalculator.cxx.

619 {
620  double R_sum = 0;
621  double pt = 0;
622 
623  static const SG::ConstAccessor<TrackParticleLinks_t> isoTrackLinksAcc("isoTrackLinks");
624  if (!isoTrackLinksAcc.isAvailable(xDiTau) )
625  {
626  ATH_MSG_WARNING("Link not available");
627  }
628 
629  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
630  if (n_subjetsAcc(xDiTau) < 2) {
631  return m_dDefault;
632  }
633 
634  for (int i = 0; i<=1; i++)
635  {
636 
637  TrackParticleLinks_t xIsoTracks = xDiTau.isoTrackLinks();
638 
639  TLorentzVector tlvSubjet;
640  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(i),
641  xDiTau.subjetEta(i),
642  xDiTau.subjetPhi(i),
643  xDiTau.subjetE(i) );
644 
645  TLorentzVector tlvIsoTrack;
646 
647  for (const auto& xIsoTrack: xIsoTracks)
648  {
649  tlvIsoTrack.SetPtEtaPhiE( (*xIsoTrack)->pt(),
650  (*xIsoTrack)->eta(),
651  (*xIsoTrack)->phi(),
652  (*xIsoTrack)->e() );
653 
654  if (tlvSubjet.DeltaR(tlvIsoTrack) < 0.4)
655  {
656  R_sum += tlvSubjet.DeltaR(tlvIsoTrack)*tlvIsoTrack.Pt();
657  pt += tlvIsoTrack.Pt();
658  }
659  }
660  }
661 
662  if (pt == 0)
663  {
664  return m_dDefault;
665  }
666 
667  return R_sum / pt;
668 }

◆ R_max()

float DiTauIDVarCalculator::R_max ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 269 of file DiTauIDVarCalculator.cxx.

270 {
271  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
272  if (iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
273  return m_dDefault;
274  }
275 
276  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
277 
278  TLorentzVector tlvSubjet;
279  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(iSubjet),
280  xDiTau.subjetEta(iSubjet),
281  xDiTau.subjetPhi(iSubjet),
282  xDiTau.subjetE(iSubjet) );
283 
284  TLorentzVector tlvTrack;
285  TLorentzVector tlvRmaxTrack;
286  double Rmax = 0;
287  static const SG::ConstAccessor<float> R_subjetAcc("R_subjet");
288  for (const auto &xTrack: xTracks)
289  {
290  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
291  (*xTrack)->eta(),
292  (*xTrack)->phi(),
293  (*xTrack)->e() );
294 
295  if ( tlvSubjet.DeltaR(tlvTrack) < R_subjetAcc(xDiTau) )
296  {
297  if (tlvTrack.DeltaR(tlvSubjet) > Rmax)
298  {
299  Rmax = tlvTrack.DeltaR(tlvSubjet);
300  }
301  }
302  }
303 
304  return Rmax;
305 }

◆ R_subjets()

float DiTauIDVarCalculator::R_subjets ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 911 of file DiTauIDVarCalculator.cxx.

912 {
913 
914  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
915  if ( iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
916  return m_dDefault;
917  }
918 
919  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
920  if (!trackLinksAcc.isAvailable(xDiTau) )
921  {
922  ATH_MSG_WARNING("Track links not available");
923  }
924 
925  TLorentzVector tlvLeadSubjet;
926  tlvLeadSubjet.SetPtEtaPhiE( xDiTau.subjetPt(0),
927  xDiTau.subjetEta(0),
928  xDiTau.subjetPhi(0),
929  xDiTau.subjetE(0) );
930 
931  TLorentzVector tlvSubjet;
932  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(iSubjet),
933  xDiTau.subjetEta(iSubjet),
934  xDiTau.subjetPhi(iSubjet),
935  xDiTau.subjetE(iSubjet) );
936  return tlvLeadSubjet.DeltaR(tlvSubjet);
937 }

◆ R_track()

float DiTauIDVarCalculator::R_track ( const xAOD::DiTauJet &  xDiTau) const
private

Definition at line 519 of file DiTauIDVarCalculator.cxx.

520 {
521  double R_sum = 0;
522  double pt = 0;
523 
524  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
525  if (!trackLinksAcc.isAvailable(xDiTau) )
526  {
527  ATH_MSG_WARNING("Link not available");
528  }
529  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
530  if (n_subjetsAcc(xDiTau) < 2) {
531  return m_dDefault;
532  }
533 
534  for (int i = 0; i<=1; i++)
535  {
536 
537  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
538 
539  TLorentzVector tlvSubjet;
540  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(i),
541  xDiTau.subjetEta(i),
542  xDiTau.subjetPhi(i),
543  xDiTau.subjetE(i) );
544 
545  TLorentzVector tlvTrack;
546 
547  for (const auto& xTrack: xTracks)
548  {
549  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
550  (*xTrack)->eta(),
551  (*xTrack)->phi(),
552  (*xTrack)->e() );
553 
554  if (tlvSubjet.DeltaR(tlvTrack) < 0.2)
555  {
556  R_sum += tlvSubjet.DeltaR(tlvTrack)*tlvTrack.Pt();
557  pt += tlvTrack.Pt();
558  }
559  }
560  }
561  if (pt == 0)
562  {
563  return m_dDefault;
564  }
565 
566  return R_sum / pt;
567 }

◆ R_track_all()

float DiTauIDVarCalculator::R_track_all ( const xAOD::DiTauJet &  xDiTau) const
private

Definition at line 569 of file DiTauIDVarCalculator.cxx.

570 {
571  double R_sum = 0;
572  double pt = 0;
573 
574  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
575  if (!trackLinksAcc.isAvailable(xDiTau) )
576  {
577  ATH_MSG_WARNING("Link not available");
578  }
579 
580  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
581  for (int i = 0; i<n_subjetsAcc(xDiTau); i++)
582  {
583 
584  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
585 
586  TLorentzVector tlvSubjet;
587  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(i),
588  xDiTau.subjetEta(i),
589  xDiTau.subjetPhi(i),
590  xDiTau.subjetE(i) );
591 
592  TLorentzVector tlvTrack;
593 
594  for (const auto& xTrack: xTracks)
595  {
596  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
597  (*xTrack)->eta(),
598  (*xTrack)->phi(),
599  (*xTrack)->e() );
600 
601  if (tlvSubjet.DeltaR(tlvTrack) <= 0.2)
602  {
603  R_sum += tlvSubjet.DeltaR(tlvTrack)*tlvTrack.Pt();
604  pt += tlvTrack.Pt();
605  }
606  }
607  }
608 
609  if (pt == 0)
610  {
611  return m_dDefault;
612  }
613 
614  return R_sum / pt;
615 }

◆ R_track_core()

float DiTauIDVarCalculator::R_track_core ( const xAOD::DiTauJet &  xDiTau) const
private

Definition at line 466 of file DiTauIDVarCalculator.cxx.

467 {
468  double R_sum = 0;
469  double pt = 0;
470 
471  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
472  if (!trackLinksAcc.isAvailable(xDiTau) )
473  {
474  ATH_MSG_WARNING("Link not available");
475  }
476  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
477  if (n_subjetsAcc(xDiTau) < 2) {
478  return m_dDefault;
479  }
480 
481 
482  for (int i = 0; i<=1; i++)
483  {
484 
485  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
486 
487  TLorentzVector tlvSubjet;
488  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(i),
489  xDiTau.subjetEta(i),
490  xDiTau.subjetPhi(i),
491  xDiTau.subjetE(i) );
492 
493  TLorentzVector tlvTrack;
494 
495  static const SG::ConstAccessor<float> R_coreAcc("R_core");
496  for (const auto& xTrack: xTracks)
497  {
498  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
499  (*xTrack)->eta(),
500  (*xTrack)->phi(),
501  (*xTrack)->e() );
502  if ( tlvSubjet.DeltaR(tlvTrack) < R_coreAcc(xDiTau) )
503  {
504  //ATH_MSG_DEBUG("smaller");
505  R_sum += tlvSubjet.DeltaR(tlvTrack)*tlvTrack.Pt();
506  pt += tlvTrack.Pt();
507  }
508  }
509  }
510  if (pt == 0)
511  {
512  return m_dDefault;
513  }
514 
515  return R_sum / pt;
516 }

◆ R_tracks()

float DiTauIDVarCalculator::R_tracks ( const xAOD::DiTauJet &  xDiTau,
int  iSubjet 
) const
private

Definition at line 367 of file DiTauIDVarCalculator.cxx.

368 {
369  double R_sum = 0;
370  double pt = 0;
371 
372  static const SG::ConstAccessor<TrackParticleLinks_t> trackLinksAcc("trackLinks");
373  if (!trackLinksAcc.isAvailable(xDiTau) )
374  {
375  ATH_MSG_WARNING("Link not available");
376  }
377 
378  static const SG::ConstAccessor<int> n_subjetsAcc("n_subjets");
379  if (iSubjet < 0 || iSubjet >= n_subjetsAcc(xDiTau)) {
380  return m_dDefault;
381  }
382 
383  TrackParticleLinks_t xTracks = xDiTau.trackLinks();
384 
385  TLorentzVector tlvSubjet;
386  tlvSubjet.SetPtEtaPhiE( xDiTau.subjetPt(iSubjet),
387  xDiTau.subjetEta(iSubjet),
388  xDiTau.subjetPhi(iSubjet),
389  xDiTau.subjetE(iSubjet) );
390 
391  TLorentzVector tlvTrack;
392 
393  for (const auto& xTrack: xTracks)
394  {
395  tlvTrack.SetPtEtaPhiE( (*xTrack)->pt(),
396  (*xTrack)->eta(),
397  (*xTrack)->phi(),
398  (*xTrack)->e() );
399 
400  if ( tlvSubjet.DeltaR(tlvTrack) < 0.2 )
401  {
402  //ATH_MSG_DEBUG("smaller");
403  R_sum += tlvSubjet.DeltaR(tlvTrack)*tlvTrack.Pt();
404  pt += tlvTrack.Pt();
405  }
406  }
407 
408  if (pt == 0)
409  {
410  return m_dDefault;
411  }
412 
413  return R_sum / pt;
414 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_dDefault

float DiTauRecTools::DiTauIDVarCalculator::m_dDefault
private

Definition at line 94 of file DiTauIDVarCalculator.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
DiTauRecTools::DiTauIDVarCalculator::R_max
float R_max(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:269
DiTauRecTools::DiTauIDVarCalculator::ditau_pt
float ditau_pt(const xAOD::DiTauJet &xDiTau) const
Definition: DiTauIDVarCalculator.cxx:170
xAOD::DiTauJet_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
DiTauRecTools::DiTauIDVarCalculator::f_core
float f_core(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:182
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
xAOD::DiTauJet_v1::fCore
float fCore(unsigned int numSubjet) const
Definition: DiTauJet_v1.cxx:168
DiTauRecTools::DiTauIDVarCalculator::R_track
float R_track(const xAOD::DiTauJet &xDiTau) const
Definition: DiTauIDVarCalculator.cxx:519
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
DiTauRecTools::DiTauIDVarCalculator::f_isotracks
float f_isotracks(const xAOD::DiTauJet &xDiTau) const
Definition: DiTauIDVarCalculator.cxx:986
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
DiTauRecTools::DiTauIDVarCalculator::mass_track_all
float mass_track_all(const xAOD::DiTauJet &xDiTau) const
Definition: DiTauIDVarCalculator.cxx:851
xAOD::DiTauJet_v1::subjetPhi
float subjetPhi(unsigned int numSubjet) const
Definition: DiTauJet_v1.cxx:112
DiTauRecTools::DiTauIDVarCalculator::n_track
static int n_track(const xAOD::DiTauJet &xDiTau)
Definition: DiTauIDVarCalculator.cxx:309
test_pyathena.pt
pt
Definition: test_pyathena.py:11
DiTauRecTools::DiTauIDVarCalculator::R_tracks
float R_tracks(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:367
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
DiTauRecTools::DiTauIDVarCalculator::d0_leadtrack
float d0_leadtrack(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:940
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
DiTauRecTools::DiTauIDVarCalculator::R_subjets
float R_subjets(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:911
DiTauRecTools::DiTauIDVarCalculator::n_isotrack
static int n_isotrack(const xAOD::DiTauJet &xDiTau)
Definition: DiTauIDVarCalculator.cxx:361
DiTauRecTools::DiTauIDVarCalculator::R_isotrack
float R_isotrack(const xAOD::DiTauJet &xDiTau) const
Definition: DiTauIDVarCalculator.cxx:618
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
xAOD::DiTauJet_v1::subjetE
float subjetE(unsigned int numSubjet) const
Definition: DiTauJet_v1.cxx:122
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
DiTauRecTools::DiTauIDVarCalculator::R_core
float R_core(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:417
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
DiTauRecTools::DiTauIDVarCalculator::R_track_all
float R_track_all(const xAOD::DiTauJet &xDiTau) const
Definition: DiTauIDVarCalculator.cxx:569
DiTauRecTools::DiTauIDVarCalculator::mass_track
float mass_track(const xAOD::DiTauJet &xDiTau) const
Definition: DiTauIDVarCalculator.cxx:819
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
DiTauRecTools::DiTauIDVarCalculator::mass_core
float mass_core(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:723
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:59
lumiFormat.i
int i
Definition: lumiFormat.py:85
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TrackParticleLinks_t
std::vector< ElementLink< xAOD::TrackParticleContainer > > TrackParticleLinks_t
Definition: DiTauIDVarCalculator.cxx:38
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
DiTauRecTools::DiTauIDVarCalculator::mass_track_core
float mass_track_core(const xAOD::DiTauJet &xDiTau) const
Definition: DiTauIDVarCalculator.cxx:671
python.xAODType.dummy
dummy
Definition: xAODType.py:4
DiTauRecTools::DiTauIDVarCalculator::E_frac
float E_frac(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:900
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
DiTauRecTools::DiTauIDVarCalculator::m_dDefault
float m_dDefault
Definition: DiTauIDVarCalculator.h:94
DiTauRecTools::DiTauIDVarCalculator::f_subjet
float f_subjet(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:194
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::DiTauJet_v1::subjetEta
float subjetEta(unsigned int numSubjet) const
Definition: DiTauJet_v1.cxx:102
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
xAOD::DiTauJet_v1::nIsoTracks
size_t nIsoTracks() const
Definition: DiTauJet_v1.cxx:290
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::DiTauJet_v1::nTracks
size_t nTracks() const
Definition: DiTauJet_v1.cxx:258
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
DiTauRecTools::DiTauIDVarCalculator::R_track_core
float R_track_core(const xAOD::DiTauJet &xDiTau) const
Definition: DiTauIDVarCalculator.cxx:466
DiTauRecTools::DiTauIDVarCalculator::f_track
float f_track(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:218
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DiTauRecTools::DiTauIDVarCalculator::decorNtracks
static StatusCode decorNtracks(const xAOD::DiTauJet &xDiTau)
Definition: DiTauIDVarCalculator.cxx:1013
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
DiTauRecTools::DiTauIDVarCalculator::f_subjets
float f_subjets(const xAOD::DiTauJet &xDiTau) const
Definition: DiTauIDVarCalculator.cxx:206
xAOD::DiTauJet_v1::isoTrackLinks
const TrackParticleLinks_t & isoTrackLinks() const
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::DiTauJet_v1::subjetPt
float subjetPt(unsigned int numSubjet) const
Definition: DiTauJet_v1.cxx:92
DiTauRecTools::DiTauIDVarCalculator::n_tracks
int n_tracks(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:315
xAOD::DiTauJet_v1::trackLinks
const TrackParticleLinks_t & trackLinks() const
DiTauRecTools::DiTauIDVarCalculator::n_subjets
static float n_subjets(const xAOD::DiTauJet &xDiTau)
Definition: DiTauIDVarCalculator.cxx:158
SG::DataProxy
Definition: DataProxy.h:44
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
DiTauRecTools::DiTauIDVarCalculator::execute
virtual StatusCode execute(const xAOD::DiTauJet &xDiTau) override
Declare the interface that the class provides.
Definition: DiTauIDVarCalculator.cxx:69
fitman.k
k
Definition: fitman.py:528
DiTauRecTools::DiTauIDVarCalculator::mass_tracks
float mass_tracks(const xAOD::DiTauJet &xDiTau, int iSubjet) const
Definition: DiTauIDVarCalculator.cxx:773
Generated on Thu Nov 7 2024 22:13:39 for ATLAS Offline Software by   doxygen 1.8.18