ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
Analysis::BTagLightSecVertexing Class Reference

#include <BTagLightSecVertexing.h>

Inheritance diagram for Analysis::BTagLightSecVertexing:
Collaboration diagram for Analysis::BTagLightSecVertexing:

Public Member Functions

 BTagLightSecVertexing (const std::string &, const std::string &, const IInterface *)
 Constructors and destructors. More...
 
virtual ~BTagLightSecVertexing ()=default
 
virtual StatusCode initialize () override
 
virtual StatusCode BTagSecVertexing_exec (const xAOD::JetContainer *jetContainer, xAOD::BTaggingContainer *btaggingContainer) const override
 
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
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 AlgTool interface methods. More...
 

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

StatusCode fillVkalVariables (const xAOD::Jet &, xAOD::BTagging *, const Trk::VxSecVKalVertexInfo *, const xAOD::TrackParticleContainer *, const std::string &) const
 
StatusCode fillJFVariables (const xAOD::Jet &, xAOD::BTagging *, const Trk::VxJetFitterVertexInfo *, const xAOD::TrackParticleContainer *, const std::string &) 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...
 

Private Attributes

ToolHandle< IJetFitterVariablesFactory > m_JFvarFactory
 
std::vector< std::string > m_secVertexFinderTrackNameList
 
std::vector< std::string > m_secVertexFinderBaseNameList
 
SG::ReadHandleKey< xAOD::VertexContainer > m_VertexCollectionName {this, "vxPrimaryCollectionName", "", "Input primary vertex container"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_jetSVLinkName { this, "JetSecVtxLinkName", "", "Element Link vector form jet to SV container"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_jetSVFlipLinkName { this, "JetSecVtxFlipLinkName", "", "Element Link vector form jet to SVFlip container"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_jetJFVtxLinkName { this, "JetJFVtxLinkName", "", "Element Link vector form jet to JF vertex"}
 
SG::ReadDecorHandleKey< xAOD::JetContainer > m_jetJFFlipVtxLinkName { this, "JetJFFlipVtxLinkName", "", "Element Link vector form jet to JF vertexFlip"}
 
SG::ReadHandleKeyArray< Trk::VxSecVertexInfoContainer > m_VxSecVertexInfoNames {this, "BTagVxSecVertexInfoNames", {""}, "Input VxSecVertexInfo containers"}
 
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 37 of file BTagLightSecVertexing.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ BTagLightSecVertexing()

Analysis::BTagLightSecVertexing::BTagLightSecVertexing ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Constructors and destructors.

Definition at line 32 of file BTagLightSecVertexing.cxx.

32  :
33  AthAlgTool(t,n,p),
34  m_JFvarFactory("Analysis::JetFitterVariablesFactory",this)
35  {
36  declareInterface<IBTagLightSecVertexing>(this);
37 
38  //List of the secondary vertex finders in jet to be used
39  declareProperty("SecVtxFinderTrackNameList", m_secVertexFinderTrackNameList);
40  declareProperty("SecVtxFinderxAODBaseNameList", m_secVertexFinderBaseNameList);
41  declareProperty("JetFitterVariableFactory", m_JFvarFactory);
42  }

◆ ~BTagLightSecVertexing()

virtual Analysis::BTagLightSecVertexing::~BTagLightSecVertexing ( )
virtualdefault

Member Function Documentation

◆ BTagSecVertexing_exec()

StatusCode Analysis::BTagLightSecVertexing::BTagSecVertexing_exec ( const xAOD::JetContainer *  jetContainer,
xAOD::BTaggingContainer *  btaggingContainer 
) const
overridevirtual

warning -> will not work if at some point we decide to associate to several track collections at the same time (in the same assoc object)

for loop on jets

Implements Analysis::IBTagLightSecVertexing.

Definition at line 307 of file BTagLightSecVertexing.cxx.

307  {
308 
309  const xAOD::Vertex* primaryVertex(nullptr);
310 
311  //retrieve primary vertex
312  SG::ReadHandle<xAOD::VertexContainer> h_VertexCollectionName (m_VertexCollectionName);
313  if (!h_VertexCollectionName.isValid()) {
314  ATH_MSG_ERROR( " cannot retrieve primary vertex container with key " << m_VertexCollectionName.key() );
315  return StatusCode::FAILURE;
316  }
317  unsigned int nVertexes = h_VertexCollectionName->size();
318  if (nVertexes == 0) {
319  ATH_MSG_DEBUG("#BTAG# Vertex container is empty");
320  return StatusCode::SUCCESS;
321  }
322  for (const auto *fz : *h_VertexCollectionName) {
323  if (fz->vertexType() == xAOD::VxType::PriVtx) {
324  primaryVertex = fz;
325  break;
326  }
327  }
328 
329 
330  if (! primaryVertex) {
331  ATH_MSG_DEBUG("#BTAG# No vertex labeled as VxType::PriVtx!");
332  xAOD::VertexContainer::const_iterator fz = h_VertexCollectionName->begin();
333  primaryVertex = *fz;
334  if (primaryVertex->nTrackParticles() == 0) {
335  ATH_MSG_DEBUG("#BTAG# PV==BeamSpot: probably poor tagging");
336  }
337  }
338 
339  int nameiter = 0;
340  for(const SG::ReadHandleKey<Trk::VxSecVertexInfoContainer>& infoCont : m_VxSecVertexInfoNames) {
341  SG::ReadHandle<Trk::VxSecVertexInfoContainer> h_VxSecVertexInfoName(infoCont);
342  if (h_VxSecVertexInfoName.isValid()) {
343  if (h_VxSecVertexInfoName->size() != jetContainer->size()) {
344  ATH_MSG_ERROR("Size of jet container different than size of VxSecVertexInfo: " << infoCont.key());
345  return StatusCode::FAILURE;
346  }
347 
348  Trk::VxSecVertexInfoContainer::const_iterator infoSVIter = h_VxSecVertexInfoName->begin();
349  xAOD::BTaggingContainer::iterator btagIter=btaggingContainer->begin();
350 
351  for (xAOD::JetContainer::const_iterator jetIter = jetContainer->begin(); jetIter != jetContainer->end(); ++jetIter, ++btagIter, ++infoSVIter) {
352  const xAOD::Jet& jetToTag = **jetIter;
353  const Trk::VxSecVertexInfo* myVertexInfo = *infoSVIter;
354 
355  const xAOD::TrackParticleContainer* theTrackParticleContainer = nullptr;
356 
357  std::string trackname = m_secVertexFinderTrackNameList[nameiter];
358  std::string basename = m_secVertexFinderBaseNameList[nameiter];
359 
360  SG::AuxElement::ConstAccessor<std::vector<ElementLink< xAOD::TrackParticleContainer > > >
361  trackAcc (trackname);
362  std::vector<ElementLink< xAOD::TrackParticleContainer > > tracksInJet;
363  tracksInJet = trackAcc (**btagIter);
364 
365  std::vector<ElementLink< xAOD::TrackParticleContainer > >::iterator itEL = tracksInJet.begin();
366  std::vector<ElementLink< xAOD::TrackParticleContainer > >::iterator itELend = tracksInJet.end();
367 
368  if(tracksInJet.empty()){
369  ATH_MSG_DEBUG("#BTAG# no tracks associated to the jet. Set some with the track selection tool " << trackname << " for VertexFinderxAODBaseName "<< basename);
370  if("SV1" == basename ||"SV1Flip" == basename ){
371  std::vector<ElementLink<xAOD::TrackParticleContainer> > TrkList;
372  (*btagIter)->setSV1_TrackParticleLinks(TrkList);
373  std::vector<ElementLink<xAOD::TrackParticleContainer> > badtrackEL;
374  (*btagIter)->setVariable<std::vector<ElementLink<xAOD::TrackParticleContainer> > >(basename, "badTracksIP", badtrackEL);
375  (*btagIter)->setDynTPELName(basename, "badTracksIP");
376  std::vector< ElementLink< xAOD::VertexContainer > > SVertexLinks;
377  (*btagIter)->setVariable<std::vector<ElementLink<xAOD::VertexContainer> > >(basename, "vertices", SVertexLinks);
378  (*btagIter)->setDynVxELName(basename, "vertices");
379  }
380  else if("MSV" == basename){
381  std::vector<ElementLink<xAOD::TrackParticleContainer> > badtrackEL;
382  (*btagIter)->setVariable<std::vector<ElementLink<xAOD::TrackParticleContainer> > >(basename, "badTracksIP", badtrackEL);
383  (*btagIter)->setDynTPELName(basename, "badTracksIP");
384  std::vector< ElementLink< xAOD::VertexContainer > > SVertexLinks;
385  (*btagIter)->setVariable<std::vector<ElementLink<xAOD::VertexContainer> > >(basename, "vertices", SVertexLinks);
386  (*btagIter)->setDynVxELName(basename, "vertices");
387  }
388  else if("JetFitter" == basename || "JetFitterFlip" == basename) {
389  std::vector< ElementLink< xAOD::TrackParticleContainer > > tracksAtPVlinks;
390  (*btagIter)->setVariable<std::vector< ElementLink< xAOD::TrackParticleContainer > > >(basename, "tracksAtPVlinks", tracksAtPVlinks);
391  (*btagIter)->setDynTPELName(basename, "tracksAtPVlinks");
392  }
393  }
394 
395  for ( ; itEL != itELend; ++itEL ) {
397 
398  theTrackParticleContainer = (*itEL).getStorableObjectPointer();
399  }
400 
401  if (basename == "SV1" || basename == "SV1Flip") {
402  const Trk::VxSecVKalVertexInfo* myVertexInfoVKal = dynamic_cast<const Trk::VxSecVKalVertexInfo*>(myVertexInfo);
403  ATH_MSG_DEBUG("#BTAG# Found valid VKalVertexInfo information: " << infoCont.key());
404  StatusCode sc = fillVkalVariables(**jetIter, *btagIter, myVertexInfoVKal, theTrackParticleContainer, basename);
405  if(sc.isFailure()){
406  ATH_MSG_ERROR("#BTAG# error filling variables from VxSecVKalVertexInfo for " << basename);
407  return sc;
408  }
409  } else if (basename == "JetFitter" || basename == "JetFitterFlip") {
410  const Trk::VxJetFitterVertexInfo* myVertexInfoJetFitter = dynamic_cast<const Trk::VxJetFitterVertexInfo*>(myVertexInfo);
411  ATH_MSG_DEBUG("#BTAG# Found valid VxJetFitterVertexInfo information: " << infoCont.key());
412  StatusCode sc = fillJFVariables(jetToTag, *btagIter, myVertexInfoJetFitter, theTrackParticleContainer, basename);
413  if(sc.isFailure()){
414  ATH_MSG_ERROR("#BTAG# error filling variables from VxJetFitterVertexInfo for " << basename);
415  return sc;
416  }
417  } else {
418  ATH_MSG_DEBUG("#BTAG# BTagLightSecVertexing: VxSecVertexInfo pointer cannot be interpreted for " << basename);
419  }
420  }
421  }
422  else {
423  ATH_MSG_DEBUG("#BTAG# VxJetFitterVertexInfo container " << infoCont.key() << " is not valid");
424  }
425  ++nameiter;
426  }// for loop on sec vertex info containers
427 
428  return StatusCode::SUCCESS;
429  }

◆ 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  }

◆ 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; }

◆ 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; }

◆ 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

◆ fillJFVariables()

StatusCode Analysis::BTagLightSecVertexing::fillJFVariables ( const xAOD::Jet &  myJet,
xAOD::BTagging *  newBTag,
const Trk::VxJetFitterVertexInfo *  myVertexInfoJetFitter,
const xAOD::TrackParticleContainer *  theTrackParticleContainer,
const std::string &  basename 
) const
private

Definition at line 174 of file BTagLightSecVertexing.cxx.

178  {
179 
180  //THIS is a nasty hack from VD but by it's more likely we get GNN to work than someone to re-organise JetFitter
181  const auto& key = basename.find("Flip")!=std::string::npos ? m_jetJFFlipVtxLinkName : m_jetJFVtxLinkName;
182  SG::ReadDecorHandle<xAOD::JetContainer, std::vector<ElementLink< xAOD::BTagVertexContainer> > > h_jetJFVtxLinkName ( key );
183  std::vector< ElementLink< xAOD::BTagVertexContainer > > JFVerticesLinks;
184 
185  //twotrackVerticesInJet
186  std::vector< const xAOD::Vertex*> vecTwoTrkVtx;
187  if (myVertexInfoJetFitter) {
188  const Trk::TwoTrackVerticesInJet* TwoTrkVtxInJet = myVertexInfoJetFitter->getTwoTrackVerticesInJet();
189  vecTwoTrkVtx = TwoTrkVtxInJet->getTwoTrackVertice();
190  if (!h_jetJFVtxLinkName.isAvailable()) {
191  ATH_MSG_ERROR( " cannot retrieve vertex container EL decoration with key " << key.key() );
192  return StatusCode::FAILURE;
193  }
194  JFVerticesLinks = h_jetJFVtxLinkName(myJet);
195  }
196 
197  int N2TrkVtx = vecTwoTrkVtx.size();
198  if("JetFitter" == basename){
199  newBTag->setTaggerInfo(N2TrkVtx, xAOD::BTagInfo::JetFitter_N2Tpair);
200  }
201  else{
202  newBTag->setVariable<int>(basename, "N2Tpair", N2TrkVtx);
203  }
204 
205  //list of JFvertices
206  std::vector<Trk::VxJetCandidate*> JFvertices;
207  if (myVertexInfoJetFitter) JFvertices = myVertexInfoJetFitter->verticesJF();
208 
209  int nVtx = 0;
210  Trk::VxJetCandidate* vxjetcand = nullptr;
211  std::vector<Trk::VxVertexOnJetAxis*> Vtxonjetaxes;
212  if (!JFvertices.empty()) {
213  vxjetcand = dynamic_cast< Trk::VxJetCandidate*>(JFvertices[0]);
214  if (!vxjetcand) {
215  ATH_MSG_WARNING("#BTAG# bad VxCandidate is not a VxJetCandidate");
216  return StatusCode::SUCCESS;
217  }
218 
219  //vtx on jet axis
220  Vtxonjetaxes = vxjetcand->getVerticesOnJetAxis();
221  }
222 
223  nVtx = Vtxonjetaxes.size();
224  typedef std::vector<ElementLink<xAOD::BTagVertexContainer> > BTagVertices;
225  ATH_MSG_DEBUG("#BTAGJF# filling vertices for basename: " << basename);
226  newBTag->setVariable<std::vector<ElementLink<xAOD::BTagVertexContainer> > >(basename, "JFvertices", JFVerticesLinks);
227  newBTag->setDynBTagVxELName(basename, "JFvertices");
228  static const SG::AuxElement::ConstAccessor<BTagVertices> vertsAcc (basename + "_JFvertices");
229  ATH_MSG_DEBUG("#BTAGJF# n vertices: " << vertsAcc (*newBTag).size());
230 
231  Amg::VectorX vtxPositions = Amg::VectorX::Zero(5);
232  Amg::MatrixX vtxCovMatrix = Amg::MatrixX::Zero(5,5);
233  if (nVtx > 0){
234  const Trk::RecVertexPositions& recVtxposition = vxjetcand->getRecVertexPositions();
235  vtxPositions = recVtxposition.position();
236  vtxCovMatrix = recVtxposition.covariancePosition();
237  ATH_MSG_DEBUG("#BTAGJF# size vtxPosition "<<vtxPositions.size());
238  }
239  std::vector< float > fittedPosition = std::vector<float>(nVtx+5,-1);
240  std::vector< float > fittedCov = std::vector<float>(nVtx+5,-1); //only store the diagonal terms
241  if(vtxPositions.rows()>4 ) {
242  fittedPosition[0] = vtxPositions[Trk::jet_xv]; //position x,y,z of PV
243  fittedPosition[1] = vtxPositions[Trk::jet_yv];
244  fittedPosition[2] = vtxPositions[Trk::jet_zv];
245  fittedPosition[3] = nVtx > 0 ? vtxPositions[Trk::jet_phi] : NAN; // direction of the jet axis
246  fittedPosition[4] = nVtx > 0 ? vtxPositions[Trk::jet_theta] : NAN;
247 
248  fittedCov[0] = vtxCovMatrix(0,0);
249  fittedCov[1] = vtxCovMatrix(1,1);
250  fittedCov[2] = vtxCovMatrix(2,2);
251  fittedCov[3] = vtxCovMatrix(3,3);
252  fittedCov[4] = vtxCovMatrix(4,4);
253  }
254 
255  for(int i=0; i<nVtx; ++i){
256  fittedPosition[i+5] = vtxPositions[i+5]; //dist of vtxi on jet axis from PV
257  fittedCov[i+5] = vtxCovMatrix(i+5,i+5);
258  }
259 
260  newBTag->setVariable<std::vector< float > >(basename, "fittedPosition", fittedPosition);
261  newBTag->setVariable<std::vector< float > >(basename, "fittedCov", fittedCov);
262 
263  //trks at PV
264  std::vector<Trk::VxTrackAtVertex*> trackatPV;
265  std::vector< float > tracksAtPVchi2;
266  std::vector< float > tracksAtPVndf;
267  std::vector< ElementLink< xAOD::TrackParticleContainer > > tracksAtPVlinks;
268  if (vxjetcand) {
269  trackatPV = vxjetcand->getPrimaryVertex()->getTracksAtVertex();
270  std::vector<Trk::VxTrackAtVertex*>::const_iterator irBegin = trackatPV.begin();
271  std::vector<Trk::VxTrackAtVertex*>::const_iterator irEnd = trackatPV.end();
272  for (std::vector<Trk::VxTrackAtVertex*>::const_iterator it=irBegin; it!=irEnd; ++it) {
273  const Trk::FitQuality& trkquality = (*it)->trackQuality();
274  double tmpchi2 = trkquality.chiSquared();
275  int tmpndf = trkquality.numberDoF();
276  tracksAtPVchi2.push_back(float(tmpchi2));
277  tracksAtPVndf.push_back(float(tmpndf));
278  //links
279  Trk::ITrackLink* trklinks = (*it)->trackOrParticleLink();
280  const Trk::LinkToXAODTrackParticle* trkLinkTPxAOD = dynamic_cast<const Trk::LinkToXAODTrackParticle *>(trklinks);
281  if (!trkLinkTPxAOD) {
282  ATH_MSG_WARNING("#BTAG# bad ITrackLink is not a LinkToXAODTrackParticle");
283  continue;
284  }
285  const xAOD::TrackParticle* myTrklink = **trkLinkTPxAOD;
286  ElementLink<xAOD::TrackParticleContainer> tpel;
287  tpel.toContainedElement(*theTrackParticleContainer, myTrklink);
288  tracksAtPVlinks.push_back(tpel);
289  }
290  }
291 
292  newBTag->setVariable<std::vector< float > >(basename, "tracksAtPVchi2", tracksAtPVchi2);
293  newBTag->setVariable<std::vector< float > >(basename, "tracksAtPVndf", tracksAtPVndf);
294  newBTag->setVariable<std::vector< ElementLink< xAOD::TrackParticleContainer > > >(basename, "tracksAtPVlinks", tracksAtPVlinks);
295  newBTag->setDynTPELName(basename, "tracksAtPVlinks");
296 
297  StatusCode sc = m_JFvarFactory->fillJetFitterVariables(myJet, newBTag, myVertexInfoJetFitter, basename);
298  if(sc.isFailure()){
299  ATH_MSG_ERROR("#BTAG# error filling variables in JetFitterVariablesFactory" );
300  return sc;
301  }
302 
303  return StatusCode::SUCCESS;
304 
305  }

◆ fillVkalVariables()

StatusCode Analysis::BTagLightSecVertexing::fillVkalVariables ( const xAOD::Jet &  myJet,
xAOD::BTagging *  newBTag,
const Trk::VxSecVKalVertexInfo *  myVertexInfoVKal,
const xAOD::TrackParticleContainer *  theTrackParticleContainer,
const std::string &  basename 
) const
private

Definition at line 78 of file BTagLightSecVertexing.cxx.

82  {
83 
84  const auto& key = basename.find("Flip")!=std::string::npos ? m_jetSVFlipLinkName : m_jetSVLinkName;
85  SG::ReadDecorHandle<xAOD::JetContainer, std::vector<ElementLink< xAOD::VertexContainer> > > h_jetSVLinkName (key);
86 
87  std::vector< ElementLink< xAOD::VertexContainer > > SVertexLinks;
88  if (myVertexInfoVKal) {
89  if (!h_jetSVLinkName.isAvailable()) {
90  ATH_MSG_ERROR( " cannot retrieve vertex container EL decoration with key " << m_jetSVLinkName.key() );
91  return StatusCode::FAILURE;
92  }
93  SVertexLinks = h_jetSVLinkName(myJet);
94  }
95 
96  std::vector<ElementLink<xAOD::TrackParticleContainer> > TrkList;
97  float mass = 0, energyfrc = NAN, energyTrk = 0, dsttomatlayer = NAN;
98  int n2trk = 0, npsec = 0;
99 
100  if(basename.find("MSV") != 0){
101  if (myVertexInfoVKal) {
102  std::vector<xAOD::Vertex*>::const_iterator verticesBegin = myVertexInfoVKal->vertices().begin();
103  std::vector<xAOD::Vertex*>::const_iterator verticesEnd = myVertexInfoVKal->vertices().end();
104  for (std::vector<xAOD::Vertex*>::const_iterator verticesIter = verticesBegin; verticesIter!=verticesEnd;++verticesIter) {
105  std::vector<ElementLink<xAOD::TrackParticleContainer> > theseTracks = (*verticesIter)->trackParticleLinks();
106  npsec += theseTracks.size();
107  for (auto & theseTrack : theseTracks){
108  TrkList.push_back(theseTrack);
109  }
110  }
111  }
112 
113  ATH_MSG_DEBUG("#BTAG# Size of the sec vertex linked to the BTagging: " << SVertexLinks.size());
114  newBTag->setVariable<std::vector<ElementLink<xAOD::VertexContainer> > >(basename, "vertices", SVertexLinks);
115  newBTag->setDynVxELName(basename, "vertices");
116 
117  if(!SVertexLinks.empty() && myVertexInfoVKal){
118  mass = myVertexInfoVKal->mass();
119  energyfrc = myVertexInfoVKal->energyFraction();
120  n2trk = myVertexInfoVKal->n2trackvertices();
121  energyTrk = myVertexInfoVKal->energyTrkInJet();
122  dsttomatlayer= myVertexInfoVKal->dstToMatLay();
123  }
124 
125  newBTag->setVariable<float>(basename, "energyTrkInJet", energyTrk);
126  newBTag->setVariable<float>(basename, "dstToMatLay", dsttomatlayer);
127 
128  if("SV1" == basename){
129  newBTag->setTaggerInfo(mass, xAOD::BTagInfo::SV1_masssvx);
130  newBTag->setTaggerInfo(energyfrc, xAOD::BTagInfo::SV1_efracsvx);
131  newBTag->setTaggerInfo(n2trk, xAOD::BTagInfo::SV1_N2Tpair);
132  newBTag->setTaggerInfo(npsec, xAOD::BTagInfo::SV1_NGTinSvx);
133  newBTag->setSV1_TrackParticleLinks(TrkList);
134  }
135  else if ("SV0" == basename){
136  newBTag->setTaggerInfo(mass, xAOD::BTagInfo::SV0_masssvx);
137  newBTag->setTaggerInfo(energyfrc, xAOD::BTagInfo::SV0_efracsvx);
138  newBTag->setTaggerInfo(n2trk, xAOD::BTagInfo::SV0_N2Tpair);
139  newBTag->setTaggerInfo(npsec, xAOD::BTagInfo::SV0_NGTinSvx);
140  newBTag->setSV0_TrackParticleLinks(TrkList);
141  } else{
142  newBTag->setVariable<float>(basename, "masssvx", mass);
143  newBTag->setVariable<float>(basename, "efracsvx", energyfrc);
144  newBTag->setVariable<int>(basename, "N2Tpair", n2trk);
145  newBTag->setVariable<int>(basename, "NGTinSvx", npsec);
146  newBTag->setVariable<std::vector<ElementLink<xAOD::TrackParticleContainer> > >(basename, "TrackParticleLinks", TrkList);
147  newBTag->setDynTPELName(basename, "TrackParticleLinks");
148  }
149  }//no msv
150  std::vector<ElementLink<xAOD::TrackParticleContainer> > badtrackEL;
151  if(theTrackParticleContainer && myVertexInfoVKal){
152  std::vector<const xAOD::IParticle*> btip = myVertexInfoVKal->badTracksIP();
153 
154  std::vector<const xAOD::IParticle*>::iterator ipBegin = btip.begin();
155  std::vector<const xAOD::IParticle*>::iterator ipEnd = btip.end();
156  for (std::vector<const xAOD::IParticle*>::iterator ipIter=ipBegin; ipIter!=ipEnd; ++ipIter) {
157  const xAOD::TrackParticle* tp = dynamic_cast<const xAOD::TrackParticle*>(*ipIter);
158  if (!tp) {
159  ATH_MSG_WARNING("#BTAG# bad track IParticle is not a TrackParticle");
160  continue;
161  }
162  ElementLink<xAOD::TrackParticleContainer> tpel;
163  tpel.toContainedElement(*theTrackParticleContainer, tp);
164  badtrackEL.push_back(tpel);
165  }
166  }
167  newBTag->setVariable<std::vector<ElementLink<xAOD::TrackParticleContainer> > >(basename, "badTracksIP", badtrackEL);
168  newBTag->setDynTPELName(basename, "badTracksIP");
169 
170  return StatusCode::SUCCESS;
171 
172  }

◆ initialize()

StatusCode Analysis::BTagLightSecVertexing::initialize ( )
overridevirtual

Implements Analysis::IBTagLightSecVertexing.

Definition at line 44 of file BTagLightSecVertexing.cxx.

45  {
46  // This will check that the properties were initialized properly
47  // by job configuration.
48  ATH_CHECK( m_VertexCollectionName.initialize() );
49  ATH_CHECK( m_jetSVLinkName.initialize() );
50  ATH_CHECK( m_jetSVFlipLinkName.initialize(!m_jetSVFlipLinkName.empty()) );
51  ATH_CHECK( m_jetJFVtxLinkName.initialize() );
52  ATH_CHECK( m_jetJFFlipVtxLinkName.initialize(!m_jetJFFlipVtxLinkName.empty()));
53  ATH_CHECK( m_VxSecVertexInfoNames.initialize() );
54 
55  /* ----------------------------------------------------------------------------------- */
56  /* RETRIEVE SERVICES FROM STOREGATE */
57  /* ----------------------------------------------------------------------------------- */
58 
59  if ( m_secVertexFinderBaseNameList.empty()) {
60  ATH_MSG_ERROR("SecVtxBaseNameList is empty");
61  return StatusCode::FAILURE;
62  }
63 
64  if(m_secVertexFinderTrackNameList.size() != m_secVertexFinderBaseNameList.size()){
65  ATH_MSG_ERROR("#BTAG# Size mismatch between secVertexFinderBaseName and track name list ");
66  return StatusCode::FAILURE;
67  }
68 
69  if ( m_JFvarFactory.retrieve().isFailure() ) {
70  ATH_MSG_ERROR("#BTAG# Failed to retrieve " << m_JFvarFactory);
71  } else {
72  ATH_MSG_DEBUG("#BTAG# Retrieved " << m_JFvarFactory);
73  }
74 
75  return StatusCode::SUCCESS;
76  }

◆ 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.

◆ interfaceID()

static const InterfaceID& Analysis::IBTagLightSecVertexing::interfaceID ( )
inlinestaticinherited

AlgTool interface methods.

Definition at line 25 of file IBTagLightSecVertexing.h.

25 { return IID_IBTagLightSecVertexing; };

◆ 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  }

◆ 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  }

◆ 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.

◆ 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_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_jetJFFlipVtxLinkName

SG::ReadDecorHandleKey<xAOD::JetContainer> Analysis::BTagLightSecVertexing::m_jetJFFlipVtxLinkName { this, "JetJFFlipVtxLinkName", "", "Element Link vector form jet to JF vertexFlip"}
private

Definition at line 61 of file BTagLightSecVertexing.h.

◆ m_jetJFVtxLinkName

SG::ReadDecorHandleKey<xAOD::JetContainer> Analysis::BTagLightSecVertexing::m_jetJFVtxLinkName { this, "JetJFVtxLinkName", "", "Element Link vector form jet to JF vertex"}
private

Definition at line 60 of file BTagLightSecVertexing.h.

◆ m_jetSVFlipLinkName

SG::ReadDecorHandleKey<xAOD::JetContainer> Analysis::BTagLightSecVertexing::m_jetSVFlipLinkName { this, "JetSecVtxFlipLinkName", "", "Element Link vector form jet to SVFlip container"}
private

Definition at line 59 of file BTagLightSecVertexing.h.

◆ m_jetSVLinkName

SG::ReadDecorHandleKey<xAOD::JetContainer> Analysis::BTagLightSecVertexing::m_jetSVLinkName { this, "JetSecVtxLinkName", "", "Element Link vector form jet to SV container"}
private

Definition at line 58 of file BTagLightSecVertexing.h.

◆ m_JFvarFactory

ToolHandle<IJetFitterVariablesFactory> Analysis::BTagLightSecVertexing::m_JFvarFactory
private

Definition at line 52 of file BTagLightSecVertexing.h.

◆ m_secVertexFinderBaseNameList

std::vector<std::string> Analysis::BTagLightSecVertexing::m_secVertexFinderBaseNameList
private

Definition at line 55 of file BTagLightSecVertexing.h.

◆ m_secVertexFinderTrackNameList

std::vector<std::string> Analysis::BTagLightSecVertexing::m_secVertexFinderTrackNameList
private

Definition at line 54 of file BTagLightSecVertexing.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_VertexCollectionName

SG::ReadHandleKey<xAOD::VertexContainer> Analysis::BTagLightSecVertexing::m_VertexCollectionName {this, "vxPrimaryCollectionName", "", "Input primary vertex container"}
private

Definition at line 57 of file BTagLightSecVertexing.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_VxSecVertexInfoNames

SG::ReadHandleKeyArray<Trk::VxSecVertexInfoContainer> Analysis::BTagLightSecVertexing::m_VxSecVertexInfoNames {this, "BTagVxSecVertexInfoNames", {""}, "Input VxSecVertexInfo containers"}
private

Definition at line 62 of file BTagLightSecVertexing.h.

The documentation for this class was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Trk::VertexPositions::position
const Amg::VectorX & position() const
return position of vertex
Definition: VertexPositions.cxx:95
Analysis::BTagLightSecVertexing::m_VxSecVertexInfoNames
SG::ReadHandleKeyArray< Trk::VxSecVertexInfoContainer > m_VxSecVertexInfoNames
Definition: BTagLightSecVertexing.h:62
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
Trk::VxJetCandidate::getVerticesOnJetAxis
const std::vector< VxVertexOnJetAxis * > & getVerticesOnJetAxis(void) const
Definition: VxJetCandidate.cxx:543
Amg::VectorX
Eigen::Matrix< double, Eigen::Dynamic, 1 > VectorX
Dynamic Vector - dynamic allocation.
Definition: EventPrimitives.h:32
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:29
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
Trk::VxSecVKalVertexInfo::n2trackvertices
int n2trackvertices() const
Definition: VxSecVKalVertexInfo.h:177
Trk::VxVertexOnJetAxis::getTracksAtVertex
const std::vector< VxTrackAtVertex * > & getTracksAtVertex(void) const
get Tracks At Vertex Method
Definition: VxVertexOnJetAxis.cxx:102
Trk::VxJetFitterVertexInfo::getTwoTrackVerticesInJet
const Trk::TwoTrackVerticesInJet * getTwoTrackVerticesInJet() const
Definition: VxJetFitterVertexInfo.h:100
Trk::jet_theta
@ jet_theta
Definition: JetVtxParamDefs.h:28
Analysis::BTagLightSecVertexing::m_secVertexFinderBaseNameList
std::vector< std::string > m_secVertexFinderBaseNameList
Definition: BTagLightSecVertexing.h:55
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::VxSecVertexInfo::vertices
const std::vector< xAOD::Vertex * > & vertices() const
Definition: VxSecVertexInfo.cxx:100
skel.it
it
Definition: skel.GENtoEVGEN.py:423
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
ParticleTest.tp
tp
Definition: ParticleTest.py:25
Trk::jet_xv
@ jet_xv
Definition: JetVtxParamDefs.h:27
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::BTagLightSecVertexing::m_secVertexFinderTrackNameList
std::vector< std::string > m_secVertexFinderTrackNameList
Definition: BTagLightSecVertexing.h:54
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::ReadHandleKey
Property holding a SG store/key/clid from which a ReadHandle is made.
Definition: StoreGate/StoreGate/ReadHandleKey.h:39
xAOD::BTagging_v1::setDynTPELName
void setDynTPELName(const std::string &taggername, const std::string &variablename)
Definition: BTagging_v1.cxx:537
dqt_zlumi_pandas.mass
mass
Definition: dqt_zlumi_pandas.py:170
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
xAOD::BTagging_v1::setSV0_TrackParticleLinks
void setSV0_TrackParticleLinks(const TPELVec_t &value)
set vector of SV0 TrackParticle ElementLinks
Definition: BTagging_v1.cxx:45
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Trk::VxSecVKalVertexInfo::mass
double mass() const
Definition: VxSecVKalVertexInfo.h:157
Trk::VxJetCandidate::getRecVertexPositions
const Trk::RecVertexPositions & getRecVertexPositions() const
Definition: VxJetCandidate.cxx:519
Analysis::BTagLightSecVertexing::m_JFvarFactory
ToolHandle< IJetFitterVariablesFactory > m_JFvarFactory
Definition: BTagLightSecVertexing.h:52
Trk::VxJetCandidate::getPrimaryVertex
const VxVertexOnJetAxis * getPrimaryVertex(void) const
Definition: VxJetCandidate.cxx:551
Trk::TwoTrackVerticesInJet
Definition: TwoTrackVerticesInJet.h:45
xAOD::BTagging_v1::setVariable
void setVariable(const std::string &taggername, const std::string &variablename, const T &value)
set variables by string
Definition: BTagging_v1.h:310
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
DataModel_detail::iterator
(Non-const) Iterator class for DataVector/DataList.
Definition: DVLIterator.h:184
lumiFormat.i
int i
Definition: lumiFormat.py:92
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
Trk::jet_yv
@ jet_yv
Definition: JetVtxParamDefs.h:27
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
Trk::LinkToXAODTrackParticle
Element link to XAOD TrackParticle.
Definition: LinkToXAODTrackParticle.h:33
Trk::VxSecVKalVertexInfo::dstToMatLay
double dstToMatLay() const
Definition: VxSecVKalVertexInfo.h:169
xAOD::BTagging_v1::setDynBTagVxELName
void setDynBTagVxELName(const std::string &taggername, const std::string &variablename)
Definition: BTagging_v1.cxx:548
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::SV1_efracsvx
@ SV1_efracsvx
SV1 : energy fraction.
Definition: BTaggingEnums.h:39
Trk::FitQuality
Class to represent and store fit qualities from track reconstruction in terms of and number of degre...
Definition: FitQuality.h:97
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::SV0_N2Tpair
@ SV0_N2Tpair
SV0 : Number of 2-track pairs.
Definition: BTaggingEnums.h:22
DataVector< xAOD::TrackParticle_v1 >
Trk::VxSecVKalVertexInfo::badTracksIP
std::vector< const xAOD::IParticle * > badTracksIP() const
Definition: VxSecVKalVertexInfo.cxx:162
xAOD::SV0_efracsvx
@ SV0_efracsvx
SV0 : energy fraction.
Definition: BTaggingEnums.h:26
Trk::VxJetFitterVertexInfo
Definition: VxJetFitterVertexInfo.h:58
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
Analysis::BTagLightSecVertexing::m_jetJFVtxLinkName
SG::ReadDecorHandleKey< xAOD::JetContainer > m_jetJFVtxLinkName
Definition: BTagLightSecVertexing.h:60
Trk::VxSecVKalVertexInfo::energyTrkInJet
double energyTrkInJet() const
Definition: VxSecVKalVertexInfo.h:165
JetAnalysisAlgorithmsTest_EMTopo_eljob.jetContainer
string jetContainer
Definition: JetAnalysisAlgorithmsTest_EMTopo_eljob.py:36
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Analysis::BTagLightSecVertexing::m_jetSVLinkName
SG::ReadDecorHandleKey< xAOD::JetContainer > m_jetSVLinkName
Definition: BTagLightSecVertexing.h:58
xAOD::JetFitter_N2Tpair
@ JetFitter_N2Tpair
JetFitter : Number of 2-track pairs.
Definition: BTaggingEnums.h:60
Analysis::BTagLightSecVertexing::fillJFVariables
StatusCode fillJFVariables(const xAOD::Jet &, xAOD::BTagging *, const Trk::VxJetFitterVertexInfo *, const xAOD::TrackParticleContainer *, const std::string &) const
Definition: BTagLightSecVertexing.cxx:174
xAOD::SV1_NGTinSvx
@ SV1_NGTinSvx
SV1 : Number of good tracks in vertex.
Definition: BTaggingEnums.h:33
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
Analysis::BTagLightSecVertexing::fillVkalVariables
StatusCode fillVkalVariables(const xAOD::Jet &, xAOD::BTagging *, const Trk::VxSecVKalVertexInfo *, const xAOD::TrackParticleContainer *, const std::string &) const
Definition: BTagLightSecVertexing.cxx:78
Trk::VxSecVertexInfo
Definition: VxSecVertexInfo.h:63
Trk::jet_zv
@ jet_zv
position x,y,z of primary vertex
Definition: JetVtxParamDefs.h:27
Analysis::BTagLightSecVertexing::m_VertexCollectionName
SG::ReadHandleKey< xAOD::VertexContainer > m_VertexCollectionName
Definition: BTagLightSecVertexing.h:57
Trk::VxJetCandidate
Definition: VxJetCandidate.h:72
Trk::RecVertexPositions
Definition: RecVertexPositions.h:34
Trk::VxSecVKalVertexInfo::energyFraction
double energyFraction() const
Definition: VxSecVKalVertexInfo.h:161
Trk::VxSecVKalVertexInfo
Definition: VxSecVKalVertexInfo.h:70
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
Trk::RecVertexPositions::covariancePosition
Amg::MatrixX const & covariancePosition() const
return the covDeltaV matrix of the vertex fit
Definition: RecVertexPositions.cxx:171
a
TList * a
Definition: liststreamerinfos.cxx:10
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::SV0_masssvx
@ SV0_masssvx
SV0 : vertex mass.
Definition: BTaggingEnums.h:24
Analysis::BTagLightSecVertexing::m_jetJFFlipVtxLinkName
SG::ReadDecorHandleKey< xAOD::JetContainer > m_jetJFFlipVtxLinkName
Definition: BTagLightSecVertexing.h:61
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
xAOD::BTagging_v1::setSV1_TrackParticleLinks
void setSV1_TrackParticleLinks(const TPELVec_t &value)
set vector of SV1 TrackParticle ElementLinks
Definition: BTagging_v1.cxx:114
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
Trk::FitQuality::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
Trk::jet_phi
@ jet_phi
Definition: JetVtxParamDefs.h:28
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
Trk::FitQuality::numberDoF
int numberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as integer
Definition: FitQuality.h:60
Trk::VxJetFitterVertexInfo::verticesJF
const std::vector< Trk::VxJetCandidate * > & verticesJF() const
Definition: VxJetFitterVertexInfo.h:112
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
xAOD::BTagging_v1::setTaggerInfo
void setTaggerInfo(int value, BTagInfo info)
set taggers information (int)
Analysis::BTagLightSecVertexing::m_jetSVFlipLinkName
SG::ReadDecorHandleKey< xAOD::JetContainer > m_jetSVFlipLinkName
Definition: BTagLightSecVertexing.h:59
Trk::TwoTrackVerticesInJet::getTwoTrackVertice
const std::vector< const xAOD::Vertex * > & getTwoTrackVertice() const
Get the two track vertices (please do not delete the pointers)
Definition: TwoTrackVerticesInJet.cxx:149
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
xAOD::BTagging_v1::setDynVxELName
void setDynVxELName(const std::string &taggername, const std::string &variablename)
Definition: BTagging_v1.cxx:542
xAOD::SV1_masssvx
@ SV1_masssvx
SV1 : vertex mass.
Definition: BTaggingEnums.h:37
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
beamspotman.basename
basename
Definition: beamspotman.py:640
Generated on Fri Jun 28 2024 22:12:16 for ATLAS Offline Software by   doxygen 1.8.18