ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
Prompt::NonPromptLeptonVertexingAlg Class Reference

#include <NonPromptLeptonVertexingAlg.h>

Inheritance diagram for Prompt::NonPromptLeptonVertexingAlg:
Collaboration diagram for Prompt::NonPromptLeptonVertexingAlg:

Public Member Functions

 NonPromptLeptonVertexingAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
virtual StatusCode finalize () override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. 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 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 SG::AuxElement::Decorator< std::vector< int > > decoratorVecInt_t
 
typedef SG::AuxElement::Decorator< std::vector< ElementLink< xAOD::VertexContainer > > > decoratorVecElemVtx_t
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

std::vector< const xAOD::TrackParticle * > findNearbyTracks (const xAOD::TrackParticle &tracklep, const xAOD::TrackParticleContainer &inDetTracks, const xAOD::Vertex &priVtx) const
 
bool passElecCand (const xAOD::Electron &elec) const
 
bool passMuonCand (const xAOD::Muon &muon) const
 
std::vector< std::unique_ptr< xAOD::Vertex > > prepLepWithTwoTrkSVVec (const FittingInput &input, const xAOD::TrackParticle *tracklep, const std::vector< const xAOD::TrackParticle * > &tracks)
 
std::vector< std::unique_ptr< xAOD::Vertex > > prepLepWithMergedSVVec (const FittingInput &input, const xAOD::TrackParticle *tracklep, std::vector< std::unique_ptr< xAOD::Vertex >> &twoTrkVertices)
 
void makeVertexCluster (std::vector< std::unique_ptr< xAOD::Vertex >> &clusterVtxs, std::vector< std::unique_ptr< xAOD::Vertex >> &inputVtxs)
 
void saveSecondaryVertices (std::vector< std::unique_ptr< xAOD::Vertex >> &vtxs, std::vector< int > &indexVector, std::vector< ElementLink< xAOD::VertexContainer > > &svLinks, xAOD::VertexContainer &SVContainer, std::set< xAOD::Vertex * > &svSet)
 
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< Prompt::IVertexMergingToolm_vertexMerger
 
ToolHandle< Prompt::VertexFittingToolm_vertexFitterTool
 
Gaudi::Property< bool > m_printTime {this, "PrintTime", false}
 
Gaudi::Property< bool > m_selectTracks {this, "SelectTracks", true}
 
Gaudi::Property< double > m_mergeMinVtxDist {this, "MergeMinVtxDist", 1.0}
 
Gaudi::Property< double > m_mergeChi2OverDoF {this, "MergeChi2OverDoF", 5.0}
 
Gaudi::Property< std::string > m_decoratorNameSecVtxLinks {this, "SecVtxLinksName", "default"}
 
Gaudi::Property< std::string > m_decoratorNameDeepMergedSecVtxLinks {this, "DeepMergedSecVtxLinksName", "default"}
 
Gaudi::Property< std::string > m_decoratorNameIndexVector {this, "IndexVectorName"}
 
Gaudi::Property< std::string > m_linkNameRefittedPriVtxWithoutLepton {this, "NoLeptonPriVtxLinkName"}
 
Gaudi::Property< std::string > m_refittedVertexTypeName
 
Gaudi::Property< float > m_minTrackpT {this, "minTrackpT", 500.0}
 
Gaudi::Property< float > m_maxTrackEta {this, "maxTrackEta", 2.5}
 
Gaudi::Property< float > m_maxTrackZ0Sin {this, "maxTrackZ0Sin", 1.0}
 
Gaudi::Property< float > m_minTrackLeptonDR {this, "minTrackLeptonDR", 1.0e-6}
 
Gaudi::Property< float > m_maxTrackLeptonDR {this, "maxTrackLeptonDR", 0.4}
 
Gaudi::Property< unsigned > m_minTrackSiHits {this, "minTrackSiHits", 7}
 
Gaudi::Property< float > m_maxTrackSharedSiHits {this, "maxTrackSharedSiHits", 1.0}
 
Gaudi::Property< unsigned > m_maxTrackSiHoles {this, "maxTrackSiHoles", 2}
 
Gaudi::Property< unsigned > m_maxTrackPixHoles {this, "maxTrackPixHoles", 1}
 
SG::ReadHandleKey< xAOD::TrackParticleContainerm_inDetTracksKey
 
SG::ReadHandleKey< xAOD::IParticleContainerm_leptonContainerKey
 
SG::ReadHandleKey< xAOD::VertexContainerm_primaryVertexContainerName
 
SG::ReadHandleKey< xAOD::VertexContainerm_refittedPriVtxContainerName
 
SG::WriteHandleKey< xAOD::VertexContainerm_svContainerName
 
TStopwatch m_timerAll
 
TStopwatch m_timerExec
 
unsigned m_countEvents
 
std::unique_ptr< decoratorVecInt_tm_indexVectorDec
 
std::unique_ptr< decoratorVecInt_tm_indexVectorDecDeepMerge
 
std::unique_ptr< decoratorVecElemVtx_tm_lepSVElementLinksDec
 
std::unique_ptr< decoratorVecElemVtx_tm_lepDeepMergedSVElementLinksDec
 
DataObjIDColl m_extendedExtraObjects
 
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 54 of file NonPromptLeptonVertexingAlg.h.

Member Typedef Documentation

◆ decoratorVecElemVtx_t

Definition at line 114 of file NonPromptLeptonVertexingAlg.h.

◆ decoratorVecInt_t

Definition at line 113 of file NonPromptLeptonVertexingAlg.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ NonPromptLeptonVertexingAlg()

Prompt::NonPromptLeptonVertexingAlg::NonPromptLeptonVertexingAlg ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 21 of file NonPromptLeptonVertexingAlg.cxx.

21  :
22  AthAlgorithm (name, pSvcLocator),
23  m_countEvents (0)
24 {}

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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 Prompt::NonPromptLeptonVertexingAlg::execute ( )
overridevirtual

Definition at line 104 of file NonPromptLeptonVertexingAlg.cxx.

105 {
106  //
107  // Start execute timer for new event
108  //
109  TimerScopeHelper timer(m_timerExec);
110 
111  m_countEvents++;
112 
113  //
114  // Find Inner Detector tracks save them class member variable for convenience.
115  //
117  if (!h_inDetTracks.isValid()){
118  ATH_MSG_FATAL("execute - failed to find the InDetTrackParticles");
119  return StatusCode::FAILURE;
120  }
121 
122  const xAOD::TrackParticleContainer inDetTracks = *h_inDetTracks;
123 
124  //
125  // Create vertex containers and record them in StoreGate
126  //
127  std::set< xAOD::Vertex* > svSet;
128 
130  ATH_CHECK(h_SVContainer.record(
131  std::make_unique< xAOD::VertexContainer>(), std::make_unique< xAOD::VertexAuxContainer>()
132  ));
133  xAOD::VertexContainer &SVContainerRef = *(h_SVContainer.ptr());
134 
135  //
136  // Retrieve containers from evtStore
137  //
141 
142  ATH_MSG_DEBUG ("NonPromptLeptonVertexingAlg::execute - Read " << vertices->size() << " primary vertices");
143  ATH_MSG_DEBUG ("NonPromptLeptonVertexingAlg::execute - Read " << refittedVertices->size() << " refitted primary vertices");
144 
145  //
146  // Find default Primary Vertex
147  //
148  Prompt::FittingInput fittingInput(&inDetTracks, 0, 0);
149 
150  for(const xAOD::Vertex *vertex: *vertices) {
151  if(vertex->vertexType() == xAOD::VxType::PriVtx) {
152  fittingInput.priVtx = vertex;
153  break;
154  }
155  }
156 
157  if(!fittingInput.priVtx) {
158  ATH_MSG_INFO("Failed to find primary vertex - skip this event");
159 
160  return StatusCode::SUCCESS;
161  }
162 
163  //
164  // Find the refitted Primary Vertex
165  //
166  for(const xAOD::Vertex *vertex: *refittedVertices) {
167  short refittedVertexType = 0;
168 
169  if(getVar(vertex, refittedVertexType, m_refittedVertexTypeName) && refittedVertexType == xAOD::VxType::PriVtx) {
170  fittingInput.refittedPriVtx = vertex;
171  }
172 
173  if(fittingInput.refittedPriVtx) {
174  break;
175  }
176  }
177 
178  //
179  // Dynamic cast IParticle container to electron or muon container
180  //
181  ATH_MSG_DEBUG("\n\t\t\t Size of lepton container: " << leptonContainer ->size());
182 
184 
185  for(const xAOD::IParticle *lepton: *leptonContainer) {
186  const xAOD::TrackParticle *tracklep = 0;
187  const xAOD::Electron *elec = dynamic_cast<const xAOD::Electron*>(lepton);
188  const xAOD::Muon *muon = dynamic_cast<const xAOD::Muon *>(lepton);
189 
190  if(elec) {
191  //
192  // Get GSF track
193  //
194  const xAOD::TrackParticle *bestmatchedGSFElTrack = elec->trackParticle(0);
195 
196  //
197  // Get original ID track for vertex fitting
198  //
199  if(passElecCand(*elec) && bestmatchedGSFElTrack) {
200  tracklep = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(bestmatchedGSFElTrack);
201  }
202  }
203  else if(muon) {
204  if(passMuonCand(*muon) && muon->inDetTrackParticleLink().isValid()) {
205  tracklep = *(muon->inDetTrackParticleLink());
206  }
207  }
208  else {
209  ATH_MSG_WARNING("NonPromptLeptonVertexingAlg::execute - failed to find electron or muon: should never happen!");
210  }
211 
212  if(!tracklep) {
213  (*m_lepSVElementLinksDec) (*lepton) = std::vector<ElementLink<xAOD::VertexContainer> >();
214  (*m_lepDeepMergedSVElementLinksDec)(*lepton) = std::vector<ElementLink<xAOD::VertexContainer> >();
215  (*m_indexVectorDec) (*lepton) = std::vector<int>();
216  (*m_indexVectorDecDeepMerge) (*lepton) = std::vector<int>();
217 
218  ATH_MSG_DEBUG("NonPromptLeptonVertexingAlg::execute - cannot find muon->inDetTrackParticleLink() nor electron->trackParticle()");
219  continue;
220  }
221 
222  ATH_MSG_DEBUG("NonPromptLeptonVertexingAlg::execute - process new lepton track " << tracklep);
223 
224  //
225  // Find refitted primary vertex with lepton track excluded
226  //
227  fittingInput.refittedPriVtxWithoutLep = 0;
228 
229  if(priVtxWithoutLepAcc.isAvailable(*lepton)) {
230  ElementLink<xAOD::VertexContainer> vtxLink = priVtxWithoutLepAcc(*lepton);
231 
232  if(vtxLink.isValid()) {
233  fittingInput.refittedPriVtxWithoutLep = *vtxLink;
234 
235  ATH_MSG_DEBUG("DecorateSecondaryVertex - found refitted primary vertex without lepton: "
236  << m_linkNameRefittedPriVtxWithoutLepton << " with Ntrack =" << fittingInput.refittedPriVtxWithoutLep->nTrackParticles());
237  }
238  }
239 
240  //
241  // Collect tracks around the lepton track
242  //
243  std::vector<const xAOD::TrackParticle* > ifitTracks = findNearbyTracks(*tracklep, inDetTracks, *fittingInput.priVtx);
244 
245  //
246  // Fit 2-track vertices
247  //
248  std::vector<std::unique_ptr<xAOD::Vertex>> twoTrkVertices = prepLepWithTwoTrkSVVec(
249  fittingInput, tracklep, ifitTracks
250  );
251 
252  // We make a copy so we can store the list of original
253  // two-track vertices
254  std::vector<std::unique_ptr<xAOD::Vertex>> twoTrkVerticesCopy;
255  for (std::unique_ptr<xAOD::Vertex> &vtx : twoTrkVertices) {
256  std::unique_ptr<xAOD::Vertex> newVtx = std::make_unique<xAOD::Vertex>(*vtx);
257  twoTrkVerticesCopy.push_back(std::move(newVtx));
258  }
259 
260  // Deep merge 2-track vertices.
261  ATH_MSG_DEBUG("Getting deep merged vertices");
262  ATH_MSG_DEBUG("Starting with " << twoTrkVertices.size() << " 2-track vertices");
263  Prompt::MergeResultNotOwner deep_merged_result = m_vertexMerger->mergeInitVertices(
264  fittingInput, tracklep, twoTrkVertices, ifitTracks);
265 
266  //
267  // Save secondary vertices
268  //
269  std::vector<ElementLink<xAOD::VertexContainer> > svLinks;
270  std::vector<ElementLink<xAOD::VertexContainer> > deepmergeSVLinks;
271 
272  std::vector<int> indexVectorTwoTrk;
273  std::vector<int> indexVectorDeepMerged;
274 
275  //
276  // Record 2-track vertexes and simple merged vertexes
277  //
278  ATH_MSG_DEBUG("NonPromptLeptonVertexingAlg::execute --- recording " << twoTrkVerticesCopy.size() << " 2-track and simple merged vertices");
279  saveSecondaryVertices(twoTrkVerticesCopy, indexVectorTwoTrk, svLinks, SVContainerRef, svSet);
280 
281  //
282  // Record both merged multi-track vertices and also unmerged 2-track vertices
283  //
284  ATH_MSG_DEBUG("NonPromptLeptonVertexingAlg::execute --- recording " << deep_merged_result.vtxsNewMerged.size() << " merged multi-track vertices");
285  saveSecondaryVertices(deep_merged_result.vtxsNewMerged, indexVectorDeepMerged, deepmergeSVLinks, SVContainerRef, svSet);
286 
287  ATH_MSG_DEBUG("NonPromptLeptonVertexingAlg::execute --- recording " << deep_merged_result.vtxsInitPassedNotMerged.size() << " unmerged 2-track vertices");
288  saveSecondaryVertices(deep_merged_result.vtxsInitPassedNotMerged, indexVectorDeepMerged, deepmergeSVLinks, SVContainerRef, svSet);
289 
290  ATH_MSG_DEBUG ("NonPromptLeptonVertexingAlg::execute -- number of two-track SV = " << twoTrkVertices.size());
291  ATH_MSG_DEBUG ("NonPromptLeptonVertexingAlg::execute -- number of deep merged SV = " << deep_merged_result.vtxsNewMerged.size());
292 
293  (*m_lepSVElementLinksDec) (*lepton) = svLinks;
294  (*m_lepDeepMergedSVElementLinksDec)(*lepton) = deepmergeSVLinks;
295  (*m_indexVectorDec) (*lepton) = indexVectorTwoTrk;
296  (*m_indexVectorDecDeepMerge) (*lepton) = indexVectorDeepMerged;
297 
298  ATH_MSG_DEBUG("NonPromptLeptonVertexingAlg - done with lepton pT=" << tracklep->pt() << ", " << truthAsStr(*lepton) << endl
299  << "___________________________________________________________________________");
300  }
301 
302  ATH_MSG_DEBUG("SV Vertex container " << m_svContainerName << " recorded in store");
303 
304  ATH_MSG_DEBUG(" NonPromptLeptonVertexingAlg::execute - done with this event" << endl
305  << "___________________________________________________________________________");
306 
307  return StatusCode::SUCCESS;
308 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

StatusCode Prompt::NonPromptLeptonVertexingAlg::finalize ( )
overridevirtual

Definition at line 88 of file NonPromptLeptonVertexingAlg.cxx.

89 {
90  if(m_printTime) {
91  //
92  // Print full time stopwatch
93  //
94  m_timerAll.Stop();
95 
96  ATH_MSG_INFO("NonPromptLeptonVertexingAlg - total time: " << PrintResetStopWatch(m_timerAll));
97  ATH_MSG_INFO("NonPromptLeptonVertexingAlg - execute time: " << PrintResetStopWatch(m_timerExec));
98  }
99 
100  return StatusCode::SUCCESS;
101 }

◆ findNearbyTracks()

std::vector< const xAOD::TrackParticle * > Prompt::NonPromptLeptonVertexingAlg::findNearbyTracks ( const xAOD::TrackParticle tracklep,
const xAOD::TrackParticleContainer inDetTracks,
const xAOD::Vertex priVtx 
) const
private

Definition at line 350 of file NonPromptLeptonVertexingAlg.cxx.

354  {
355  //
356  // Select tracks -- avoid using track selection tool since z0 definition is different
357  //
358  std::vector<const xAOD::TrackParticle *> mytracks;
359 
360  for(const xAOD::TrackParticle *track: inDetTracks) {
361  if(!track) {
362  ATH_MSG_WARNING("skip null track pointer - should never happen");
363  continue;
364  }
365 
366  //
367  // Check minimum track and lepton DR: skip the track that is probably the lepton track
368  //
369  if(tracklep.p4().DeltaR(track->p4()) < m_minTrackLeptonDR) {
370  ATH_MSG_DEBUG("skip the track very close to the lepton ");
371  continue;
372  }
373 
374  //
375  // Check track and lepton maximum DR
376  //
377  if(tracklep.p4().DeltaR(track->p4()) > m_maxTrackLeptonDR) {
378  continue;
379  }
380 
381  const double delta_z0 = track->z0() + track->vz() - priVtx.z();
382  const double Z0Sin = std::abs(delta_z0*std::sin(track->theta()));
383  const double abs_eta = std::abs(track->eta());
384 
391 
392  if(!(track->summaryValue(numberOfPixelHits, xAOD::numberOfPixelHits))) continue;
393  if(!(track->summaryValue(numberOfSCTHits, xAOD::numberOfSCTHits))) continue;
394  if(!(track->summaryValue(numberOfPixelHoles, xAOD::numberOfPixelHoles))) continue;
395  if(!(track->summaryValue(numberOfSCTHoles, xAOD::numberOfSCTHoles))) continue;
396  if(!(track->summaryValue(numberOfPixelSharedHits, xAOD::numberOfPixelSharedHits))) continue;
397  if(!(track->summaryValue(numberOfSCTSharedHits, xAOD::numberOfSCTSharedHits))) continue;
398 
399  const uint8_t NSiHits = numberOfPixelHits + numberOfSCTHits;
400  const uint8_t NSiHoles = numberOfPixelHoles + numberOfSCTHoles;
401  const float NSiShHits = float(numberOfPixelSharedHits) + float(numberOfSCTSharedHits)/2.0;
402 
403  if(m_selectTracks) {
404  //
405  // Kinematic track selection
406  //
407  if(track->pt() < m_minTrackpT) continue;
408  if(abs_eta > m_maxTrackEta) continue;
409  if(Z0Sin > m_maxTrackZ0Sin) continue;
410 
411  //
412  // Hit quality track selection
413  //
414  if(NSiHits < m_minTrackSiHits) continue;
415  if(NSiShHits > m_maxTrackSharedSiHits) continue;
416  if(NSiHoles > m_maxTrackSiHoles ) continue;
417  if(numberOfPixelHoles > m_maxTrackPixHoles ) continue;
418  }
419 
420  mytracks.push_back(track);
421  }
422 
423  return mytracks;
424 }

◆ initialize()

StatusCode Prompt::NonPromptLeptonVertexingAlg::initialize ( )
overridevirtual

Definition at line 27 of file NonPromptLeptonVertexingAlg.cxx.

28 {
29  if(m_printTime) {
30  //
31  // Reset timers
32  //
33  m_timerAll .Reset();
34  m_timerExec.Reset();
35 
36  //
37  // Start full timer
38  //
39  m_timerAll.Start();
40  }
41 
42  if(m_svContainerName.empty()) {
43  ATH_MSG_ERROR("NonPromptLeptonVertexingAlg::initialize - empty SV container name: \"" << m_svContainerName << "\"");
44  return StatusCode::FAILURE;
45  }
46 
47  ATH_CHECK(m_vertexMerger.retrieve());
48  ATH_CHECK(m_vertexFitterTool.retrieve());
49 
51  ATH_CHECK(m_leptonContainerKey.initialize());
54 
55  ATH_CHECK(m_svContainerName.initialize());
56 
57  m_indexVectorDec = std::make_unique<decoratorVecInt_t> (m_decoratorNameIndexVector);
58  m_indexVectorDecDeepMerge = std::make_unique<decoratorVecInt_t> (m_decoratorNameIndexVector+"DeepMerge");
59 
60  m_lepSVElementLinksDec = std::make_unique<decoratorVecElemVtx_t>(m_decoratorNameSecVtxLinks);
61  m_lepDeepMergedSVElementLinksDec = std::make_unique<decoratorVecElemVtx_t>(m_decoratorNameDeepMergedSecVtxLinks);
62 
63  ATH_MSG_DEBUG("LeptonContainerName = " << m_leptonContainerKey);
64  ATH_MSG_DEBUG("ReFitPriVtxContainerName = " << m_refittedPriVtxContainerName);
65  ATH_MSG_DEBUG("SVContainerName = " << m_svContainerName);
66  ATH_MSG_DEBUG("IndexVectorName = " << m_decoratorNameIndexVector);
67 
68  ATH_MSG_DEBUG("mergeMinVtxDist = " << m_mergeMinVtxDist);
69  ATH_MSG_DEBUG("mergeChi2OverDoF = " << m_mergeChi2OverDoF);
70 
71  ATH_MSG_DEBUG("minTrackLeptonDR = " << m_minTrackLeptonDR);
72  ATH_MSG_DEBUG("maxTrackLeptonDR = " << m_maxTrackLeptonDR);
73 
74  ATH_MSG_DEBUG("selectTracks = " << m_selectTracks);
75  ATH_MSG_DEBUG("minTrackpT = " << m_minTrackpT);
76  ATH_MSG_DEBUG("maxTrackEta = " << m_maxTrackEta);
77  ATH_MSG_DEBUG("maxTrackZ0Sin = " << m_maxTrackZ0Sin);
78 
79  ATH_MSG_DEBUG("minTrackSiHits = " << m_minTrackSiHits);
80  ATH_MSG_DEBUG("maxTrackSharedSiHits = " << m_maxTrackSharedSiHits);
81  ATH_MSG_DEBUG("maxTrackSiHoles = " << m_maxTrackSiHoles);
82  ATH_MSG_DEBUG("maxTrackPixHoles = " << m_maxTrackPixHoles);
83 
84  return StatusCode::SUCCESS;
85 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

◆ makeVertexCluster()

void Prompt::NonPromptLeptonVertexingAlg::makeVertexCluster ( std::vector< std::unique_ptr< xAOD::Vertex >> &  clusterVtxs,
std::vector< std::unique_ptr< xAOD::Vertex >> &  inputVtxs 
)
private

Definition at line 575 of file NonPromptLeptonVertexingAlg.cxx.

579 {
580  ATH_MSG_DEBUG("makeVertexCluster - before: clusterVtxs.size()=" << clusterVtxs.size() << ", inputVtxs.size()=" << inputVtxs.size());
581 
582  std::vector<std::unique_ptr<xAOD::Vertex>>::iterator vit = inputVtxs.begin();
583 
584  while(vit != inputVtxs.end()) {
585  bool pass = false;
586 
587  for(std::vector<std::unique_ptr<xAOD::Vertex>>::const_iterator cit = clusterVtxs.begin(); cit != clusterVtxs.end(); ++cit) {
588  if(vit->get() == cit->get()) {
589  ATH_MSG_DEBUG("makeVertexCluster - logic error - found the same vertex twice: " << ((*vit).get()));
590  continue;
591  }
592 
593  const double vdist = getDistance((*vit)->position(), (*cit)->position());
594 
595  ATH_MSG_DEBUG("makeVertexCluster - vdist=" << vdist );
596 
597  if(vdist < m_mergeMinVtxDist) {
598  pass = true;
599  break;
600  }
601  }
602 
603  if(pass) {
604  clusterVtxs.push_back(std::move(*vit));
605  inputVtxs.erase(vit);
606 
607  vit = inputVtxs.begin();
608  }
609  else {
610  ++vit;
611  }
612  }
613 
614  ATH_MSG_DEBUG("makeVertexCluster - after: clusterVtxs.size()=" << clusterVtxs.size() << ", inputVtxs.size()=" << inputVtxs.size());
615 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::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< Algorithm >::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< Algorithm > >::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.

◆ passElecCand()

bool Prompt::NonPromptLeptonVertexingAlg::passElecCand ( const xAOD::Electron elec) const
private

Definition at line 311 of file NonPromptLeptonVertexingAlg.cxx.

312 {
313  //
314  // Check whether electron candidate passes loose selection
315  //
316  char lh_loose = -1;
317 
318  Prompt::GetAuxVar(elec, lh_loose, "DFCommonElectronsLHLoose");
319 
320  ATH_MSG_DEBUG("NonPromptLeptonVertexingAlg::passElecCand - "
321  << "pT=" << elec.pt() << ", eta=" << elec.eta() << ", phi=" << elec.phi() << std::endl
322  << " DFCommonElectronsLHLoose = " << int(lh_loose) << std::endl
323  << " " << truthAsStr(elec));
324 
325  if(!lh_loose) {
326  return false;
327  }
328 
329  return true;
330 }

◆ passMuonCand()

bool Prompt::NonPromptLeptonVertexingAlg::passMuonCand ( const xAOD::Muon muon) const
private

Definition at line 333 of file NonPromptLeptonVertexingAlg.cxx.

334 {
335  //
336  // Check whether muon candidate is a combined muon
337  //
338  const bool combined = (muon.muonType() == xAOD::Muon::Combined);
339 
340  ATH_MSG_DEBUG("NonPromptLeptonVertexingAlg::passMuonCand - "
341  << "pT=" << muon.pt() << ", eta=" << muon.eta() << ", phi=" << muon.phi() << std::endl
342  << " Type = " << muon.muonType() << std::endl
343  << " Combined = " << combined << std::endl
344  << " " << truthAsStr(muon));
345 
346  return combined;
347 }

◆ prepLepWithMergedSVVec()

std::vector< std::unique_ptr< xAOD::Vertex > > Prompt::NonPromptLeptonVertexingAlg::prepLepWithMergedSVVec ( const FittingInput input,
const xAOD::TrackParticle tracklep,
std::vector< std::unique_ptr< xAOD::Vertex >> &  twoTrkVertices 
)
private

Definition at line 466 of file NonPromptLeptonVertexingAlg.cxx.

471 {
472  //
473  // Merge the two vertices if the distance between them with in 0.5 mm.
474  // Re-fit a three-track vertex using the input tracks from the vertices above.
475  //
476  std::vector<std::unique_ptr<xAOD::Vertex>> twoTrkVerticesPass;
477  std::vector<std::unique_ptr<xAOD::Vertex>> twoTrkVerticesPassFixed;
478  std::vector<std::unique_ptr<xAOD::Vertex>> twoTrkVerticesMerged;
479  std::vector<std::unique_ptr<xAOD::Vertex>> resultVertices;
480 
481  if(!input.priVtx) {
482  ATH_MSG_WARNING("prepLepWithMergedSVVec -- invalid primary vertex: nothing to do");
483  return resultVertices;
484  }
485 
486  for(std::unique_ptr<xAOD::Vertex> &vtx: twoTrkVertices) {
487  double chi2OverDoF = -99.;
488 
489  if(vtx->numberDoF() > 0 && vtx->chiSquared() > 0) {
490  chi2OverDoF = vtx->chiSquared()/double(vtx->numberDoF());
491  }
492 
493  if(chi2OverDoF >= 0.0 && chi2OverDoF < m_mergeChi2OverDoF) {
494  twoTrkVerticesPass .push_back(std::move(vtx));
495  twoTrkVerticesPassFixed.push_back(std::move(vtx));
496  }
497  }
498 
499  std::vector<std::unique_ptr<xAOD::Vertex>>::iterator curr_iter = twoTrkVerticesPass.begin();
500 
501  while(curr_iter != twoTrkVerticesPass.end()) {
502  std::vector<std::unique_ptr<xAOD::Vertex>> clusterVtxs;
503  clusterVtxs.push_back(std::move(*curr_iter));
504 
505  twoTrkVerticesPass.erase(curr_iter);
506 
507  makeVertexCluster(clusterVtxs, twoTrkVerticesPass);
508 
509  curr_iter = twoTrkVerticesPass.begin();
510 
511  //
512  // Fit vertex cluster
513  //
514  std::vector<const xAOD::TrackParticle*> tracksForFit;
515 
516  for(std::unique_ptr<xAOD::Vertex> &vtx: clusterVtxs) {
517  for(unsigned k = 0; k < vtx->nTrackParticles(); ++k) {
518  const xAOD::TrackParticle *track = vtx->trackParticle(k);
519 
520  if(track) {
521  tracksForFit.push_back(track);
522  }
523  }
524  }
525 
526  //
527  // Ignore standalone vertexes
528  //
529  if(clusterVtxs.size() < 2) {
530  continue;
531  }
532 
533  //
534  // Fit merged vertex
535  //
536  tracksForFit.push_back(tracklep);
537 
538  std::unique_ptr<xAOD::Vertex> newSecondaryVertex = m_vertexFitterTool->fitVertexWithPrimarySeed(
539  input, tracksForFit, kSimpleMergedVtx
540  );
541 
542  if(!newSecondaryVertex) {
543  ATH_MSG_DEBUG("DecorateLepWithMergedSVVec -- failed to fit merged vertex");
544  continue;
545  }
546 
547  resultVertices.push_back(std::move(newSecondaryVertex));
548 
549  for(std::unique_ptr<xAOD::Vertex> &vtx: clusterVtxs) {
550  twoTrkVerticesMerged.push_back(std::move(vtx));
551  }
552 
553  ATH_MSG_DEBUG("DecorateLepWithMergedSVVec -- NTrack of merged vertex = " << newSecondaryVertex->nTrackParticles());
554  }
555 
556  //
557  // Include passed 2-track vertexes that were NOT merged
558  //
559  for(std::unique_ptr<xAOD::Vertex> &vtx: twoTrkVerticesPassFixed) {
560  const std::vector<std::unique_ptr<xAOD::Vertex>>::const_iterator fit = std::find(
561  twoTrkVerticesMerged.begin(),
562  twoTrkVerticesMerged.end(),
563  vtx
564  );
565 
566  if(fit == twoTrkVerticesMerged.end()) {
567  resultVertices.push_back(std::move(vtx));
568  }
569  }
570 
571  return resultVertices;
572 }

◆ prepLepWithTwoTrkSVVec()

std::vector< std::unique_ptr< xAOD::Vertex > > Prompt::NonPromptLeptonVertexingAlg::prepLepWithTwoTrkSVVec ( const FittingInput input,
const xAOD::TrackParticle tracklep,
const std::vector< const xAOD::TrackParticle * > &  tracks 
)
private

Definition at line 427 of file NonPromptLeptonVertexingAlg.cxx.

432 {
433  //
434  // Decorate lepton with vector of two-track vertices.
435  // Return vector of finding vertices
436  //
437  std::vector<std::unique_ptr<xAOD::Vertex>> twoTrkVertices;
438  std::vector<const xAOD::TrackParticle*> tracksForFit;
439 
440  if(!input.priVtx) {
441  ATH_MSG_WARNING("prepLepWithTwoTrkSVVec -- invalid primary vertex: nothing to do");
442  return twoTrkVertices;
443  }
444 
445  for(const xAOD::TrackParticle *selectedtrack: tracks) {
446  tracksForFit.clear();
447  tracksForFit.push_back(tracklep);
448  tracksForFit.push_back(selectedtrack);
449 
450  std::unique_ptr<xAOD::Vertex> newSecondaryVertex = m_vertexFitterTool->fitVertexWithPrimarySeed(
451  input, tracksForFit, kTwoTrackVtx
452  );
453 
454  if(!newSecondaryVertex) {
455  ATH_MSG_DEBUG("prepLepWithTwoTrkSVVec -- failed to fit 2-track vertex");
456  continue;
457  }
458 
459  twoTrkVertices.push_back(std::move(newSecondaryVertex));
460  }
461 
462  return twoTrkVertices;
463 }

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

◆ saveSecondaryVertices()

void Prompt::NonPromptLeptonVertexingAlg::saveSecondaryVertices ( std::vector< std::unique_ptr< xAOD::Vertex >> &  vtxs,
std::vector< int > &  indexVector,
std::vector< ElementLink< xAOD::VertexContainer > > &  svLinks,
xAOD::VertexContainer SVContainer,
std::set< xAOD::Vertex * > &  svSet 
)
private

Definition at line 618 of file NonPromptLeptonVertexingAlg.cxx.

625 {
626  //
627  // Record created xAOD::Vertex in output vertex container
628  //
629  ATH_MSG_DEBUG("saveSecondaryVertices - will save " << vtxs.size() << " vertexes");
630 
631  for(std::unique_ptr<xAOD::Vertex> &vtx: vtxs) {
632  int index = -99;
633  if(getVar(vtx, index, "SecondaryVertexIndex")) {
634  indexVector.push_back(index);
635  }
636  else {
637  ATH_MSG_WARNING("saveSecondaryVertices - missing \"SecondaryVertexIndex\" variable");
638  }
639 
640  if(svSet.insert(vtx.get()).second) {
641  //
642  // First time seeing this this vertex - record it in output container
643  //
644  SVContainer.push_back(std::move(vtx));
645  ElementLink<xAOD::VertexContainer> svLink(SVContainer,SVContainer.size()-1);
646  svLinks.push_back(svLink);
647  } else {
648  ATH_MSG_ERROR("saveSecondaryVertices --- the same vertex has been encountered more than once! Is this a logic error?");
649  }
650  }
651 
652  ATH_MSG_DEBUG("saveSecondaryVertices - all done");
653 }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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_countEvents

unsigned Prompt::NonPromptLeptonVertexingAlg::m_countEvents
private

Definition at line 183 of file NonPromptLeptonVertexingAlg.h.

◆ m_decoratorNameDeepMergedSecVtxLinks

Gaudi::Property<std::string> Prompt::NonPromptLeptonVertexingAlg::m_decoratorNameDeepMergedSecVtxLinks {this, "DeepMergedSecVtxLinksName", "default"}
private

Definition at line 139 of file NonPromptLeptonVertexingAlg.h.

◆ m_decoratorNameIndexVector

Gaudi::Property<std::string> Prompt::NonPromptLeptonVertexingAlg::m_decoratorNameIndexVector {this, "IndexVectorName"}
private

Definition at line 140 of file NonPromptLeptonVertexingAlg.h.

◆ m_decoratorNameSecVtxLinks

Gaudi::Property<std::string> Prompt::NonPromptLeptonVertexingAlg::m_decoratorNameSecVtxLinks {this, "SecVtxLinksName", "default"}
private

Definition at line 138 of file NonPromptLeptonVertexingAlg.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_inDetTracksKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> Prompt::NonPromptLeptonVertexingAlg::m_inDetTracksKey
private
Initial value:
{
this, "InDetTrackParticlesKey", "InDetTrackParticles"
}

Definition at line 160 of file NonPromptLeptonVertexingAlg.h.

◆ m_indexVectorDec

std::unique_ptr<decoratorVecInt_t> Prompt::NonPromptLeptonVertexingAlg::m_indexVectorDec
private

Definition at line 188 of file NonPromptLeptonVertexingAlg.h.

◆ m_indexVectorDecDeepMerge

std::unique_ptr<decoratorVecInt_t> Prompt::NonPromptLeptonVertexingAlg::m_indexVectorDecDeepMerge
private

Definition at line 189 of file NonPromptLeptonVertexingAlg.h.

◆ m_lepDeepMergedSVElementLinksDec

std::unique_ptr<decoratorVecElemVtx_t> Prompt::NonPromptLeptonVertexingAlg::m_lepDeepMergedSVElementLinksDec
private

Definition at line 191 of file NonPromptLeptonVertexingAlg.h.

◆ m_lepSVElementLinksDec

std::unique_ptr<decoratorVecElemVtx_t> Prompt::NonPromptLeptonVertexingAlg::m_lepSVElementLinksDec
private

Definition at line 190 of file NonPromptLeptonVertexingAlg.h.

◆ m_leptonContainerKey

SG::ReadHandleKey<xAOD::IParticleContainer> Prompt::NonPromptLeptonVertexingAlg::m_leptonContainerKey
private
Initial value:
{
this, "LeptonContainerName", "default"
}

Definition at line 163 of file NonPromptLeptonVertexingAlg.h.

◆ m_linkNameRefittedPriVtxWithoutLepton

Gaudi::Property<std::string> Prompt::NonPromptLeptonVertexingAlg::m_linkNameRefittedPriVtxWithoutLepton {this, "NoLeptonPriVtxLinkName"}
private

Definition at line 141 of file NonPromptLeptonVertexingAlg.h.

◆ m_maxTrackEta

Gaudi::Property<float> Prompt::NonPromptLeptonVertexingAlg::m_maxTrackEta {this, "maxTrackEta", 2.5}
private

Definition at line 148 of file NonPromptLeptonVertexingAlg.h.

◆ m_maxTrackLeptonDR

Gaudi::Property<float> Prompt::NonPromptLeptonVertexingAlg::m_maxTrackLeptonDR {this, "maxTrackLeptonDR", 0.4}
private

Definition at line 152 of file NonPromptLeptonVertexingAlg.h.

◆ m_maxTrackPixHoles

Gaudi::Property<unsigned> Prompt::NonPromptLeptonVertexingAlg::m_maxTrackPixHoles {this, "maxTrackPixHoles", 1}
private

Definition at line 157 of file NonPromptLeptonVertexingAlg.h.

◆ m_maxTrackSharedSiHits

Gaudi::Property<float> Prompt::NonPromptLeptonVertexingAlg::m_maxTrackSharedSiHits {this, "maxTrackSharedSiHits", 1.0}
private

Definition at line 155 of file NonPromptLeptonVertexingAlg.h.

◆ m_maxTrackSiHoles

Gaudi::Property<unsigned> Prompt::NonPromptLeptonVertexingAlg::m_maxTrackSiHoles {this, "maxTrackSiHoles", 2}
private

Definition at line 156 of file NonPromptLeptonVertexingAlg.h.

◆ m_maxTrackZ0Sin

Gaudi::Property<float> Prompt::NonPromptLeptonVertexingAlg::m_maxTrackZ0Sin {this, "maxTrackZ0Sin", 1.0}
private

Definition at line 149 of file NonPromptLeptonVertexingAlg.h.

◆ m_mergeChi2OverDoF

Gaudi::Property<double> Prompt::NonPromptLeptonVertexingAlg::m_mergeChi2OverDoF {this, "MergeChi2OverDoF", 5.0}
private

Definition at line 136 of file NonPromptLeptonVertexingAlg.h.

◆ m_mergeMinVtxDist

Gaudi::Property<double> Prompt::NonPromptLeptonVertexingAlg::m_mergeMinVtxDist {this, "MergeMinVtxDist", 1.0}
private

Definition at line 135 of file NonPromptLeptonVertexingAlg.h.

◆ m_minTrackLeptonDR

Gaudi::Property<float> Prompt::NonPromptLeptonVertexingAlg::m_minTrackLeptonDR {this, "minTrackLeptonDR", 1.0e-6}
private

Definition at line 151 of file NonPromptLeptonVertexingAlg.h.

◆ m_minTrackpT

Gaudi::Property<float> Prompt::NonPromptLeptonVertexingAlg::m_minTrackpT {this, "minTrackpT", 500.0}
private

Definition at line 147 of file NonPromptLeptonVertexingAlg.h.

◆ m_minTrackSiHits

Gaudi::Property<unsigned> Prompt::NonPromptLeptonVertexingAlg::m_minTrackSiHits {this, "minTrackSiHits", 7}
private

Definition at line 154 of file NonPromptLeptonVertexingAlg.h.

◆ m_primaryVertexContainerName

SG::ReadHandleKey<xAOD::VertexContainer> Prompt::NonPromptLeptonVertexingAlg::m_primaryVertexContainerName
private
Initial value:
{
this, "PriVertexContainerName", "PrimaryVertices"
}

Definition at line 166 of file NonPromptLeptonVertexingAlg.h.

◆ m_printTime

Gaudi::Property<bool> Prompt::NonPromptLeptonVertexingAlg::m_printTime {this, "PrintTime", false}
private

Definition at line 132 of file NonPromptLeptonVertexingAlg.h.

◆ m_refittedPriVtxContainerName

SG::ReadHandleKey<xAOD::VertexContainer> Prompt::NonPromptLeptonVertexingAlg::m_refittedPriVtxContainerName
private
Initial value:
{
this, "ReFitPriVtxContainerName", "default"
}

Definition at line 169 of file NonPromptLeptonVertexingAlg.h.

◆ m_refittedVertexTypeName

Gaudi::Property<std::string> Prompt::NonPromptLeptonVertexingAlg::m_refittedVertexTypeName
private
Initial value:
{
this, "ReFitPriVtxTypeName", "refittedVertexType"
}

Definition at line 143 of file NonPromptLeptonVertexingAlg.h.

◆ m_selectTracks

Gaudi::Property<bool> Prompt::NonPromptLeptonVertexingAlg::m_selectTracks {this, "SelectTracks", true}
private

Definition at line 133 of file NonPromptLeptonVertexingAlg.h.

◆ m_svContainerName

SG::WriteHandleKey<xAOD::VertexContainer> Prompt::NonPromptLeptonVertexingAlg::m_svContainerName
private
Initial value:
{
this, "SVContainerName", "default"
}

Definition at line 172 of file NonPromptLeptonVertexingAlg.h.

◆ m_timerAll

TStopwatch Prompt::NonPromptLeptonVertexingAlg::m_timerAll
private

Definition at line 180 of file NonPromptLeptonVertexingAlg.h.

◆ m_timerExec

TStopwatch Prompt::NonPromptLeptonVertexingAlg::m_timerExec
private

Definition at line 181 of file NonPromptLeptonVertexingAlg.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vertexFitterTool

ToolHandle<Prompt::VertexFittingTool> Prompt::NonPromptLeptonVertexingAlg::m_vertexFitterTool
private
Initial value:
{
this, "VertexFittingTool", "Prompt::VertexFittingTool/VertexFittingTool"
}

Definition at line 125 of file NonPromptLeptonVertexingAlg.h.

◆ m_vertexMerger

ToolHandle<Prompt::IVertexMergingTool> Prompt::NonPromptLeptonVertexingAlg::m_vertexMerger
private
Initial value:
{
this, "VertexMergingTool",
"Prompt::VertexMergingTool/PromptVertexMergingTool"
}

Definition at line 121 of file NonPromptLeptonVertexingAlg.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.


The documentation for this class was generated from the following files:
Prompt::NonPromptLeptonVertexingAlg::m_minTrackpT
Gaudi::Property< float > m_minTrackpT
Definition: NonPromptLeptonVertexingAlg.h:147
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Prompt::kSimpleMergedVtx
@ kSimpleMergedVtx
Definition: IVertexFittingTool.h:60
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:261
Prompt::NonPromptLeptonVertexingAlg::m_minTrackSiHits
Gaudi::Property< unsigned > m_minTrackSiHits
Definition: NonPromptLeptonVertexingAlg.h:154
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
Prompt::NonPromptLeptonVertexingAlg::m_decoratorNameSecVtxLinks
Gaudi::Property< std::string > m_decoratorNameSecVtxLinks
Definition: NonPromptLeptonVertexingAlg.h:138
Prompt::NonPromptLeptonVertexingAlg::m_maxTrackZ0Sin
Gaudi::Property< float > m_maxTrackZ0Sin
Definition: NonPromptLeptonVertexingAlg.h:149
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
Prompt::NonPromptLeptonVertexingAlg::m_timerAll
TStopwatch m_timerAll
Definition: NonPromptLeptonVertexingAlg.h:180
Prompt::NonPromptLeptonVertexingAlg::m_selectTracks
Gaudi::Property< bool > m_selectTracks
Definition: NonPromptLeptonVertexingAlg.h:133
xAOD::Vertex_v1::nTrackParticles
size_t nTrackParticles() const
Get the number of tracks associated with this vertex.
Definition: Vertex_v1.cxx:270
xAOD::numberOfSCTSharedHits
@ numberOfSCTSharedHits
number of SCT hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:272
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
Prompt::GetAuxVar
bool GetAuxVar(const T1 &obj, T2 &value, const std::string &var_name)
Definition: PromptUtils.h:93
Prompt::NonPromptLeptonVertexingAlg::m_mergeMinVtxDist
Gaudi::Property< double > m_mergeMinVtxDist
Definition: NonPromptLeptonVertexingAlg.h:135
Prompt::NonPromptLeptonVertexingAlg::m_decoratorNameDeepMergedSecVtxLinks
Gaudi::Property< std::string > m_decoratorNameDeepMergedSecVtxLinks
Definition: NonPromptLeptonVertexingAlg.h:139
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Prompt::NonPromptLeptonVertexingAlg::m_maxTrackSharedSiHits
Gaudi::Property< float > m_maxTrackSharedSiHits
Definition: NonPromptLeptonVertexingAlg.h:155
Prompt::getVar
bool getVar(T1 &obj, T2 &value, const std::string &var_name)
Definition: PromptUtils.h:72
Prompt::NonPromptLeptonVertexingAlg::m_indexVectorDec
std::unique_ptr< decoratorVecInt_t > m_indexVectorDec
Definition: NonPromptLeptonVertexingAlg.h:188
Prompt::NonPromptLeptonVertexingAlg::m_vertexFitterTool
ToolHandle< Prompt::VertexFittingTool > m_vertexFitterTool
Definition: NonPromptLeptonVertexingAlg.h:125
Prompt::NonPromptLeptonVertexingAlg::m_linkNameRefittedPriVtxWithoutLepton
Gaudi::Property< std::string > m_linkNameRefittedPriVtxWithoutLepton
Definition: NonPromptLeptonVertexingAlg.h:141
Prompt::NonPromptLeptonVertexingAlg::m_indexVectorDecDeepMerge
std::unique_ptr< decoratorVecInt_t > m_indexVectorDecDeepMerge
Definition: NonPromptLeptonVertexingAlg.h:189
Prompt::NonPromptLeptonVertexingAlg::m_countEvents
unsigned m_countEvents
Definition: NonPromptLeptonVertexingAlg.h:183
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Prompt::NonPromptLeptonVertexingAlg::m_lepSVElementLinksDec
std::unique_ptr< decoratorVecElemVtx_t > m_lepSVElementLinksDec
Definition: NonPromptLeptonVertexingAlg.h:190
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
xAOD::Electron_v1::trackParticle
const xAOD::TrackParticle * trackParticle(size_t index=0) const
Pointer to the xAOD::TrackParticle/s that match the electron candidate.
Definition: Electron_v1.cxx:55
Prompt::NonPromptLeptonVertexingAlg::m_leptonContainerKey
SG::ReadHandleKey< xAOD::IParticleContainer > m_leptonContainerKey
Definition: NonPromptLeptonVertexingAlg.h:163
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
Prompt::NonPromptLeptonVertexingAlg::m_maxTrackSiHoles
Gaudi::Property< unsigned > m_maxTrackSiHoles
Definition: NonPromptLeptonVertexingAlg.h:156
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
Prompt::FittingInput
Definition: IVertexFittingTool.h:60
Prompt::NonPromptLeptonVertexingAlg::prepLepWithTwoTrkSVVec
std::vector< std::unique_ptr< xAOD::Vertex > > prepLepWithTwoTrkSVVec(const FittingInput &input, const xAOD::TrackParticle *tracklep, const std::vector< const xAOD::TrackParticle * > &tracks)
Definition: NonPromptLeptonVertexingAlg.cxx:427
Prompt::PrintResetStopWatch
std::string PrintResetStopWatch(TStopwatch &watch)
Definition: PromptUtils.cxx:244
Prompt::NonPromptLeptonVertexingAlg::m_maxTrackEta
Gaudi::Property< float > m_maxTrackEta
Definition: NonPromptLeptonVertexingAlg.h:148
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
python.utils.AtlRunQueryTimer.timer
def timer(name, disabled=False)
Definition: AtlRunQueryTimer.py:86
Prompt::Def::Z0Sin
@ Z0Sin
Definition: VarHolder.h:86
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Prompt::NonPromptLeptonVertexingAlg::m_refittedPriVtxContainerName
SG::ReadHandleKey< xAOD::VertexContainer > m_refittedPriVtxContainerName
Definition: NonPromptLeptonVertexingAlg.h:169
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
Prompt::NonPromptLeptonVertexingAlg::m_primaryVertexContainerName
SG::ReadHandleKey< xAOD::VertexContainer > m_primaryVertexContainerName
Definition: NonPromptLeptonVertexingAlg.h:166
Prompt::NonPromptLeptonVertexingAlg::m_printTime
Gaudi::Property< bool > m_printTime
Definition: NonPromptLeptonVertexingAlg.h:132
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
Prompt::MergeResultNotOwner::vtxsInitPassedNotMerged
std::vector< std::unique_ptr< xAOD::Vertex > > vtxsInitPassedNotMerged
Definition: PhysicsAnalysis/AnalysisCommon/LeptonTaggers/LeptonTaggers/IVertexMergingTool.h:73
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:129
Prompt::NonPromptLeptonVertexingAlg::m_lepDeepMergedSVElementLinksDec
std::unique_ptr< decoratorVecElemVtx_t > m_lepDeepMergedSVElementLinksDec
Definition: NonPromptLeptonVertexingAlg.h:191
xAOD::numberOfPixelSharedHits
@ numberOfPixelSharedHits
number of Pixel all-layer hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:262
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
Prompt::NonPromptLeptonVertexingAlg::m_mergeChi2OverDoF
Gaudi::Property< double > m_mergeChi2OverDoF
Definition: NonPromptLeptonVertexingAlg.h:136
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
Prompt::NonPromptLeptonVertexingAlg::m_vertexMerger
ToolHandle< Prompt::IVertexMergingTool > m_vertexMerger
Definition: NonPromptLeptonVertexingAlg.h:121
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Prompt::getDistance
double getDistance(const xAOD::Vertex *vtx1, const xAOD::Vertex *vtx2)
Definition: PromptUtils.cxx:41
Prompt::NonPromptLeptonVertexingAlg::passElecCand
bool passElecCand(const xAOD::Electron &elec) const
Definition: NonPromptLeptonVertexingAlg.cxx:311
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
Prompt::NonPromptLeptonVertexingAlg::saveSecondaryVertices
void saveSecondaryVertices(std::vector< std::unique_ptr< xAOD::Vertex >> &vtxs, std::vector< int > &indexVector, std::vector< ElementLink< xAOD::VertexContainer > > &svLinks, xAOD::VertexContainer &SVContainer, std::set< xAOD::Vertex * > &svSet)
Definition: NonPromptLeptonVertexingAlg.cxx:618
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
Prompt::NonPromptLeptonVertexingAlg::m_maxTrackPixHoles
Gaudi::Property< unsigned > m_maxTrackPixHoles
Definition: NonPromptLeptonVertexingAlg.h:157
Prompt::NonPromptLeptonVertexingAlg::m_svContainerName
SG::WriteHandleKey< xAOD::VertexContainer > m_svContainerName
Definition: NonPromptLeptonVertexingAlg.h:172
Prompt::NonPromptLeptonVertexingAlg::m_maxTrackLeptonDR
Gaudi::Property< float > m_maxTrackLeptonDR
Definition: NonPromptLeptonVertexingAlg.h:152
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::Egamma_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle.
Definition: Egamma_v1.cxx:75
Prompt::NonPromptLeptonVertexingAlg::m_refittedVertexTypeName
Gaudi::Property< std::string > m_refittedVertexTypeName
Definition: NonPromptLeptonVertexingAlg.h:143
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::Vertex_v1::z
float z() const
Returns the z position.
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
Prompt::NonPromptLeptonVertexingAlg::findNearbyTracks
std::vector< const xAOD::TrackParticle * > findNearbyTracks(const xAOD::TrackParticle &tracklep, const xAOD::TrackParticleContainer &inDetTracks, const xAOD::Vertex &priVtx) const
Definition: NonPromptLeptonVertexingAlg.cxx:350
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
Prompt::NonPromptLeptonVertexingAlg::m_minTrackLeptonDR
Gaudi::Property< float > m_minTrackLeptonDR
Definition: NonPromptLeptonVertexingAlg.h:151
MuonValidation_CreateResolutionProfiles.fit
def fit(h, emin, emax)
Definition: MuonValidation_CreateResolutionProfiles.py:69
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
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
Prompt::truthAsStr
std::string truthAsStr(const xAOD::IParticle &particle)
Definition: PromptUtils.cxx:213
Prompt::NonPromptLeptonVertexingAlg::m_inDetTracksKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_inDetTracksKey
Definition: NonPromptLeptonVertexingAlg.h:160
Prompt::NonPromptLeptonVertexingAlg::passMuonCand
bool passMuonCand(const xAOD::Muon &muon) const
Definition: NonPromptLeptonVertexingAlg.cxx:333
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF
const xAOD::TrackParticle * getOriginalTrackParticleFromGSF(const xAOD::TrackParticle *trkPar)
Helper function for getting the "Original" Track Particle (i.e before GSF) via the GSF Track Particle...
Definition: ElectronxAODHelpers.cxx:22
xAOD::Electron_v1
Definition: Electron_v1.h:34
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
Prompt::MergeResultNotOwner::vtxsNewMerged
std::vector< std::unique_ptr< xAOD::Vertex > > vtxsNewMerged
Definition: PhysicsAnalysis/AnalysisCommon/LeptonTaggers/LeptonTaggers/IVertexMergingTool.h:70
a
TList * a
Definition: liststreamerinfos.cxx:10
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
Prompt::NonPromptLeptonVertexingAlg::m_timerExec
TStopwatch m_timerExec
Definition: NonPromptLeptonVertexingAlg.h:181
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
xAOD::Egamma_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: Egamma_v1.cxx:65
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
xAOD::Egamma_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: Egamma_v1.cxx:70
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
Prompt::NonPromptLeptonVertexingAlg::makeVertexCluster
void makeVertexCluster(std::vector< std::unique_ptr< xAOD::Vertex >> &clusterVtxs, std::vector< std::unique_ptr< xAOD::Vertex >> &inputVtxs)
Definition: NonPromptLeptonVertexingAlg.cxx:575
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
readCCLHist.float
float
Definition: readCCLHist.py:83
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
Prompt::kTwoTrackVtx
@ kTwoTrackVtx
Definition: IVertexFittingTool.h:59
Prompt::NonPromptLeptonVertexingAlg::m_decoratorNameIndexVector
Gaudi::Property< std::string > m_decoratorNameIndexVector
Definition: NonPromptLeptonVertexingAlg.h:140
Prompt::MergeResultNotOwner
Definition: PhysicsAnalysis/AnalysisCommon/LeptonTaggers/LeptonTaggers/IVertexMergingTool.h:69