Prompt::VertexFittingTool Class Reference

#include <VertexFittingTool.h>

Inheritance diagram for Prompt::VertexFittingTool:

Collaboration diagram for Prompt::VertexFittingTool:

Public Member Functions
	VertexFittingTool (const std::string &t, const std::string &name, const IInterface *p)
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual std::unique_ptr< xAOD::Vertex >	fitVertexWithPrimarySeed (const FittingInput &input, const std::vector< const xAOD::TrackParticle * > &tracks, VtxType vtx) override
virtual std::unique_ptr< xAOD::Vertex >	fitVertexWithSeed (const FittingInput &input, const std::vector< const xAOD::TrackParticle * > &tracks, const Amg::Vector3D &seed, VtxType vtxType) override
virtual bool	isValidVertex (const xAOD::Vertex *vtx) const override
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
	DeclareInterfaceID (Prompt::IVertexFittingTool, 1, 0)

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
typedef std::unique_ptr< xAOD::Vertex >	vtxPtr_t
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	removeDoubleEntries (std::vector< const xAOD::TrackParticle * > &tracks)
bool	decorateNewSecondaryVertex (const FittingInput &input, xAOD::Vertex *secVtx)
std::unique_ptr< xAOD::Vertex >	getSecondaryVertexWithSeed (const std::vector< const xAOD::TrackParticle * > &tracks, const xAOD::TrackParticleContainer *inDetTracks, const Amg::Vector3D &seed)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< Trk::IVertexFitter >	m_vertexFitter
ToolHandle< Trk::IVertexFitter >	m_seedVertexFitter
Gaudi::Property< bool >	m_doSeedVertexFit
Gaudi::Property< std::string >	m_distToPriVtxName
Gaudi::Property< std::string >	m_normDistToPriVtxName
Gaudi::Property< std::string >	m_distToRefittedPriVtxName
Gaudi::Property< std::string >	m_normDistToRefittedPriVtxName
Gaudi::Property< std::string >	m_distToRefittedRmLepPriVtxName
Gaudi::Property< std::string >	m_normDistToRefittedRmLepPriVtxName
TStopwatch	m_timer
int	m_countNumberOfFits {0}
int	m_countNumberOfFitsFailed {0}
int	m_countNumberOfFitsInvalid {0}
int	m_secondaryVertexIndex {0}
std::unique_ptr< SG::AuxElement::Decorator< float > >	m_distToPriVtx
std::unique_ptr< SG::AuxElement::Decorator< float > >	m_normDistToPriVtx
std::unique_ptr< SG::AuxElement::Decorator< float > >	m_distToRefittedPriVtx
std::unique_ptr< SG::AuxElement::Decorator< float > >	m_normDistToRefittedPriVtx
std::unique_ptr< SG::AuxElement::Decorator< float > >	m_distToRefittedRmLepPriVtx
std::unique_ptr< SG::AuxElement::Decorator< float > >	m_normDistToRefittedRmLepPriVtx
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 29 of file VertexFittingTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

vtxPtr_t

typedef std::unique_ptr<xAOD::Vertex> Prompt::VertexFittingTool::vtxPtr_t

private

Definition at line 67 of file VertexFittingTool.h.

Constructor & Destructor Documentation

VertexFittingTool()

Prompt::VertexFittingTool::VertexFittingTool	(	const std::string &	t,
		const std::string &	name,
		const IInterface *	p )

Definition at line 21 of file VertexFittingTool.cxx.

 : AthAlgTool(t, name, p)
{
  declareInterface<Prompt::IVertexFittingTool>(this);
}

Member Function Documentation

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

DeclareInterfaceID()

Prompt::IVertexFittingTool::DeclareInterfaceID ( Prompt::IVertexFittingTool , 1 , 0  )

inherited

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

decorateNewSecondaryVertex()

bool Prompt::VertexFittingTool::decorateNewSecondaryVertex ( const FittingInput & input, xAOD::Vertex * secVtx )

private

Definition at line 226 of file VertexFittingTool.cxx.

{
  //
  // Decorate secondary vertex with all useful information
  //
  if(!secVtx) {
    ATH_MSG_WARNING("decorateNewSecondaryVertex - invalid pointer");
    return false;
  }
 
  //
  // Decorate secondary vertex with the distance/norm_distance it from Prmary Vertex, Refitted Primary vertex and Refitted Primary Vertex that removed lepton itself.
  //
  float distToPriVtx                  = -1;
  float normDistToPriVtx              = -1;
  float distToRefittedPriVtx          = -1;
  float normDistToRefittedPriVtx      = -1;
  float distToRefittedRmLepPriVtx     = -1;
  float normDistToRefittedRmLepPriVtx = -1;
 
  if(input.priVtx) {
    distToPriVtx     = Prompt::getDistance(input.priVtx->position(), secVtx->position());
    normDistToPriVtx = Prompt::getNormDist(input.priVtx->position(), secVtx->position(), secVtx->covariance(), msg(MSG::WARNING));
  }
 
  if(input.refittedPriVtx) {
    distToRefittedPriVtx     = Prompt::getDistance(input.refittedPriVtx->position(), secVtx->position());
    normDistToRefittedPriVtx = Prompt::getNormDist(input.refittedPriVtx->position(), secVtx->position(), secVtx->covariance(), msg(MSG::WARNING));
  }
 
  if(input.refittedPriVtxWithoutLep) {
    distToRefittedRmLepPriVtx     = Prompt::getDistance(input.refittedPriVtxWithoutLep->position(), secVtx->position());
    normDistToRefittedRmLepPriVtx = Prompt::getNormDist(input.refittedPriVtxWithoutLep->position(), secVtx->position(), secVtx->covariance(), msg(MSG::WARNING));
  }
 
  (*m_distToPriVtx)                 (*secVtx) = distToPriVtx;
  (*m_normDistToPriVtx)             (*secVtx) = normDistToPriVtx;
  (*m_distToRefittedPriVtx)         (*secVtx) = distToRefittedPriVtx;
  (*m_normDistToRefittedPriVtx)     (*secVtx) = normDistToRefittedPriVtx;
  (*m_distToRefittedRmLepPriVtx)    (*secVtx) = distToRefittedRmLepPriVtx;
  (*m_normDistToRefittedRmLepPriVtx)(*secVtx) = normDistToRefittedRmLepPriVtx;
 
  return true;
}

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.

{ return m_detStore; }

evtStore()

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.

{ 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

finalize()

StatusCode Prompt::VertexFittingTool::finalize ( )

overridevirtual

Definition at line 53 of file VertexFittingTool.cxx.

{
  //
  // Delete pointers
  //
  m_timer.Stop();
 
  ATH_MSG_INFO("VertexFittingSvc::finalize - number of total   fits: " << m_countNumberOfFits);
  ATH_MSG_INFO("VertexFittingSvc::finalize - number of failed  fits: " << m_countNumberOfFitsFailed);
  ATH_MSG_INFO("VertexFittingSvc::finalize - number of invalid vtxs: " << m_countNumberOfFitsInvalid);
  ATH_MSG_INFO("VertexFittingSvc::finalize - fitting timer: " << PrintResetStopWatch(m_timer));
 
  return StatusCode::SUCCESS;
}

fitVertexWithPrimarySeed()

std::unique_ptr< xAOD::Vertex > Prompt::VertexFittingTool::fitVertexWithPrimarySeed ( const FittingInput & input, const std::vector< const xAOD::TrackParticle * > & tracks, VtxType vtx )

overridevirtual

Implements Prompt::IVertexFittingTool.

Definition at line 69 of file VertexFittingTool.cxx.

{
  //
  // Make new secondary vertex
  //
  TimerScopeHelper timer(m_timer);
  m_countNumberOfFits++;
 
  if(!input.priVtx) {
    ATH_MSG_WARNING("fitVertexWithPrimarySeed -- missing primary vertex");
    return nullptr;
  }
 
  // Fit a new secondary vertex
  std::unique_ptr<xAOD::Vertex> secondaryVtx = getSecondaryVertexWithSeed(
    tracks, input.inDetTracks, input.priVtx->position()
  );
 
  if(!secondaryVtx) {
    m_countNumberOfFitsFailed++;
    ATH_MSG_WARNING("fitVertexWithPrimarySeed -- failed to fit vertex");
    return nullptr;
  }
 
  if(!isValidVertex(secondaryVtx.get())) {
    m_countNumberOfFitsInvalid++;
 
    ATH_MSG_WARNING("fitVertexWithPrimarySeed -- failed to get valid vertex");
    return nullptr;
  }
 
  m_secondaryVertexIndex++;
 
  // Decorate the newly created vertex
  static const SG::AuxElement::Accessor<int> indexAcc("SecondaryVertexIndex");
  static const SG::AuxElement::Accessor<int> typeAcc("SVType");
 
  indexAcc(*secondaryVtx) = m_secondaryVertexIndex;
  typeAcc(*secondaryVtx) = static_cast<int>(vtxType);
 
  decorateNewSecondaryVertex(input, secondaryVtx.get());
 
  return secondaryVtx;
}

fitVertexWithSeed()

std::unique_ptr< xAOD::Vertex > Prompt::VertexFittingTool::fitVertexWithSeed ( const FittingInput & input, const std::vector< const xAOD::TrackParticle * > & tracks, const Amg::Vector3D & seed, VtxType vtxType )

overridevirtual

Implements Prompt::IVertexFittingTool.

Definition at line 119 of file VertexFittingTool.cxx.

{
  //
  // Make new secondary vertex
  //
  TimerScopeHelper timer(m_timer);
  m_countNumberOfFits++;
 
  std::unique_ptr<xAOD::Vertex> secondaryVtx = getSecondaryVertexWithSeed(
    tracks, input.inDetTracks, seed
  );
 
  if(!secondaryVtx) {
    m_countNumberOfFitsFailed++;
 
    ATH_MSG_WARNING("fitVertexWithSeed -- failed to fit vertex");
    return nullptr;
  }
 
  if(!isValidVertex(secondaryVtx.get())) {
    m_countNumberOfFitsInvalid++;
 
    ATH_MSG_WARNING("fitVertexWithSeed -- failed to get valid vertex");
    return nullptr;
  }
 
  m_secondaryVertexIndex++;
 
  // Decorate the newly created vertex
  static const SG::AuxElement::Accessor<int> indexAcc("SecondaryVertexIndex");
  static const SG::AuxElement::Accessor<int> typeAcc("SVType");
 
  indexAcc(*secondaryVtx) = m_secondaryVertexIndex;
  typeAcc(*secondaryVtx) = static_cast<int>(vtxType);
 
  decorateNewSecondaryVertex(input, secondaryVtx.get());
 
  return secondaryVtx;
}

getSecondaryVertexWithSeed()

std::unique_ptr< xAOD::Vertex > Prompt::VertexFittingTool::getSecondaryVertexWithSeed ( const std::vector< const xAOD::TrackParticle * > & tracks, const xAOD::TrackParticleContainer * inDetTracks, const Amg::Vector3D & seed )

private

Definition at line 275 of file VertexFittingTool.cxx.

{
  //
  // Fit one vertex with given tracks
  //
  std::vector<const xAOD::TrackParticle*> tracksForFit(tracks);
 
  ATH_MSG_DEBUG("getSecondaryVertexWithSeed -- before remove " << tracksForFit.size());
 
  removeDoubleEntries(tracksForFit);
 
  ATH_MSG_DEBUG("getSecondaryVertexWithSeed -- after remove " << tracksForFit.size());
 
  if(tracksForFit.size() < 2) {
    ATH_MSG_WARNING("getSecondaryVertexWithSeed -- cannot fit vertex with one or zero input track: ntrack=" << tracksForFit.size());
    return 0;
  }
 
  //
  // Run fit
  //
  ATH_MSG_DEBUG(name() << "::getSecondaryVertexWithSeed -- N tracks = " << tracksForFit.size());
 
  for(const xAOD::TrackParticle* track: tracksForFit) {
    ATH_MSG_DEBUG( name() << "::getSecondaryVertexWithSeed -- track pt, eta = " << track->pt() << "," << track->eta());
    ATH_MSG_DEBUG( name() << "::getSecondaryVertexWithSeed -- track chi2    = " << track->chiSquared());
  }
 
  xAOD::Vertex *newVertex = 0;
  std::unique_ptr<xAOD::Vertex> seedVertex;
 
  if(m_doSeedVertexFit) {
    seedVertex = std::unique_ptr<xAOD::Vertex>(m_seedVertexFitter->fit(tracksForFit, seed));
 
    if(seedVertex.get() && !isValidVertex(seedVertex.get())) {
      ATH_MSG_DEBUG("getSecondaryVertexWithSeed -- failed to fit seed vertex");
 
      seedVertex.reset();
    }
  }
 
  if(seedVertex.get()) {
    newVertex = m_vertexFitter->fit(tracksForFit, seedVertex->position());
  }
  else {
    newVertex = m_vertexFitter->fit(tracksForFit, seed);
  }
 
  if(!newVertex) {
    ATH_MSG_INFO("getSecondaryVertexWithSeed -- failed to fit vertex and fitter returned null xAOD::Vertex pointer");
    return 0;
  }
 
  //
  // Save vertex tracks
  //
  std::vector<ElementLink< xAOD::TrackParticleContainer> > tpLinks;
 
  if(inDetTracks) {
    //
    // Record links to ID tracks if container pointer is provided
    //
    for(const xAOD::TrackParticle *selectedtrack: tracksForFit) {
      ElementLink<xAOD::TrackParticleContainer> tpLink;
 
      tpLink.toContainedElement(*inDetTracks, selectedtrack);
      tpLinks.push_back(tpLink);
    }
  }
 
  newVertex->setTrackParticleLinks(tpLinks);
 
  TLorentzVector Momentum;
 
  for(const xAOD::TrackParticle* track: tracksForFit) {
    Momentum += static_cast<TLorentzVector>(track->p4());
  }
 
  xAOD::SecVtxHelper::setVertexMass(newVertex, Momentum.M()); // "mass"
 
  // newVertex was returned from the vertex fitter as a raw pointer
  // It looks like Trk::IVertexFitter::fit function expects
  // memory management to be done by the caller.
  // Therefore, we take ownership by casting to a unique_ptr
 
  std::unique_ptr<xAOD::Vertex> returnPtr(newVertex);
 
  return returnPtr;
}

initialize()

StatusCode Prompt::VertexFittingTool::initialize ( )

overridevirtual

Definition at line 29 of file VertexFittingTool.cxx.

{
  ATH_CHECK(m_vertexFitter.retrieve());
 
  if(m_doSeedVertexFit) {
    ATH_CHECK(m_seedVertexFitter.retrieve());
  }
 
  m_distToPriVtx                   = std::make_unique<SG::AuxElement::Decorator<float> > (m_distToPriVtxName);
  m_normDistToPriVtx               = std::make_unique<SG::AuxElement::Decorator<float> > (m_normDistToPriVtxName);
  m_distToRefittedPriVtx           = std::make_unique<SG::AuxElement::Decorator<float> > (m_distToRefittedPriVtxName);
  m_normDistToRefittedPriVtx       = std::make_unique<SG::AuxElement::Decorator<float> > (m_normDistToRefittedPriVtxName);
  m_distToRefittedRmLepPriVtx      = std::make_unique<SG::AuxElement::Decorator<float> > (m_distToRefittedRmLepPriVtxName);
  m_normDistToRefittedRmLepPriVtx  = std::make_unique<SG::AuxElement::Decorator<float> > (m_normDistToRefittedRmLepPriVtxName);
 
  m_timer.Reset();
 
  ATH_MSG_DEBUG("VertexFittingSvc::initialize - doSeedVertexFit = " << m_doSeedVertexFit);
  ATH_MSG_DEBUG("VertexFittingSvc::initialize - vertexFitter    = " << m_vertexFitter.name());
 
  return StatusCode::SUCCESS;
}

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.

isValidVertex()

bool Prompt::VertexFittingTool::isValidVertex ( const xAOD::Vertex * vtx ) const

overridevirtual

Implements Prompt::IVertexFittingTool.

Definition at line 165 of file VertexFittingTool.cxx.

{
  //
  // Check if vertex is valid
  //
  bool bad_vtx = false;
 
  if(!vtx){
    ATH_MSG_WARNING("VertexFittingSvc::Validate_Vertex -- invalid vtx pointer!!!");
    return false;
  }
 
  if(vtx->covariance().empty()) {
    bad_vtx = true;
    ATH_MSG_WARNING("VertexFittingSvc::Validate_Vertex -- empty vtx covariance!!!");
  }
 
  float chisquared = -9999;
 
  if(!getVar(vtx, chisquared, "chiSquared")) {
    bad_vtx = true;
    ATH_MSG_WARNING("VertexFittingSvc::Validate_Vertex -- not valid vtx chiSquared!!!");
  }
 
  float numberdof  = -9999;
 
  if(!getVar(vtx, numberdof, "numberDoF")) {
    bad_vtx = true;
    ATH_MSG_WARNING("VertexFittingSvc::Validate_Vertex -- not valid vtx numberDoF!!!");
  }
 
  if(std::isnan(vtx->x()) || std::isnan(vtx->y()) || std::isnan(vtx->z())) {
    bad_vtx = true;
    ATH_MSG_WARNING("VertexFittingSvc::Validate_Vertex -- vertex coordinate is nan");
  }
 
  if(bad_vtx) {
    ATH_MSG_WARNING("VertexFittingSvc::Validate_Vertex -- bad vertex!!!");
    ATH_MSG_INFO(printPromptVertexAsStr(vtx, msg(MSG::WARNING)));
  }
 
  return !bad_vtx;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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.

removeDoubleEntries()

void Prompt::VertexFittingTool::removeDoubleEntries ( std::vector< const xAOD::TrackParticle * > & tracks )

private

Definition at line 210 of file VertexFittingTool.cxx.

{
  const unsigned nbefore = tracks.size();
 
  sort(tracks.begin(), tracks.end());
 
  typename std::vector<const xAOD::TrackParticle*>::iterator TransfEnd = std::unique(tracks.begin(), tracks.end());
 
  tracks.erase(TransfEnd, tracks.end());
 
  if(nbefore != tracks.size()) {
    ATH_MSG_DEBUG("removeDoubleEntries nbefore != tracks.size()): " << nbefore << " != " << tracks.size());
  }
}

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.

  {
    h.renounce();
    PBASE::renounce (h);
  }

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.

                                                          {
    handlesArray.renounce();
  }

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_countNumberOfFits

int Prompt::VertexFittingTool::m_countNumberOfFits {0}

private

Definition at line 109 of file VertexFittingTool.h.

{0};

m_countNumberOfFitsFailed

int Prompt::VertexFittingTool::m_countNumberOfFitsFailed {0}

private

Definition at line 110 of file VertexFittingTool.h.

{0};

m_countNumberOfFitsInvalid

int Prompt::VertexFittingTool::m_countNumberOfFitsInvalid {0}

private

Definition at line 111 of file VertexFittingTool.h.

{0};

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_distToPriVtx

std::unique_ptr<SG::AuxElement::Decorator<float> > Prompt::VertexFittingTool::m_distToPriVtx

private

Definition at line 115 of file VertexFittingTool.h.

m_distToPriVtxName

Gaudi::Property<std::string> Prompt::VertexFittingTool::m_distToPriVtxName

private

Initial value:

{
        this, "DistToPriVtxName", "default"
        }

Definition at line 86 of file VertexFittingTool.h.

                                                    {
        this, "DistToPriVtxName", "default"
        };

m_distToRefittedPriVtx

std::unique_ptr<SG::AuxElement::Decorator<float> > Prompt::VertexFittingTool::m_distToRefittedPriVtx

private

Definition at line 117 of file VertexFittingTool.h.

m_distToRefittedPriVtxName

Gaudi::Property<std::string> Prompt::VertexFittingTool::m_distToRefittedPriVtxName

private

Initial value:

{
        this, "DistToRefittedPriVtxName", "default"
        }

Definition at line 92 of file VertexFittingTool.h.

                                                            {
        this, "DistToRefittedPriVtxName", "default"
        };

m_distToRefittedRmLepPriVtx

std::unique_ptr<SG::AuxElement::Decorator<float> > Prompt::VertexFittingTool::m_distToRefittedRmLepPriVtx

private

Definition at line 119 of file VertexFittingTool.h.

m_distToRefittedRmLepPriVtxName

Gaudi::Property<std::string> Prompt::VertexFittingTool::m_distToRefittedRmLepPriVtxName

private

Initial value:

{
        this, "DistToRefittedRmLepPriVtxName", "default"
        }

Definition at line 98 of file VertexFittingTool.h.

                                                                 {
        this, "DistToRefittedRmLepPriVtxName", "default"
        };

m_doSeedVertexFit

Gaudi::Property<bool> Prompt::VertexFittingTool::m_doSeedVertexFit

private

Initial value:

{
        this, "doSeedVertexFit", false
        }

Definition at line 82 of file VertexFittingTool.h.

                                              {
        this, "doSeedVertexFit", false
        };

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_normDistToPriVtx

std::unique_ptr<SG::AuxElement::Decorator<float> > Prompt::VertexFittingTool::m_normDistToPriVtx

private

Definition at line 116 of file VertexFittingTool.h.

m_normDistToPriVtxName

Gaudi::Property<std::string> Prompt::VertexFittingTool::m_normDistToPriVtxName

private

Initial value:

{
        this, "NormDistToPriVtxName", "default"
        }

Definition at line 89 of file VertexFittingTool.h.

                                                        {
        this, "NormDistToPriVtxName", "default"
        };

m_normDistToRefittedPriVtx

std::unique_ptr<SG::AuxElement::Decorator<float> > Prompt::VertexFittingTool::m_normDistToRefittedPriVtx

private

Definition at line 118 of file VertexFittingTool.h.

m_normDistToRefittedPriVtxName

Gaudi::Property<std::string> Prompt::VertexFittingTool::m_normDistToRefittedPriVtxName

private

Initial value:

{
        this, "NormDistToRefittedPriVtxName", "default"
        }

Definition at line 95 of file VertexFittingTool.h.

                                                                {
        this, "NormDistToRefittedPriVtxName", "default"
        };

m_normDistToRefittedRmLepPriVtx

std::unique_ptr<SG::AuxElement::Decorator<float> > Prompt::VertexFittingTool::m_normDistToRefittedRmLepPriVtx

private

Definition at line 120 of file VertexFittingTool.h.

m_normDistToRefittedRmLepPriVtxName

Gaudi::Property<std::string> Prompt::VertexFittingTool::m_normDistToRefittedRmLepPriVtxName

private

Initial value:

{
        this, "NormDistToRefittedRmLepPriVtxName", "default"
        }

Definition at line 101 of file VertexFittingTool.h.

                                                                     {
        this, "NormDistToRefittedRmLepPriVtxName", "default"
        };

m_secondaryVertexIndex

int Prompt::VertexFittingTool::m_secondaryVertexIndex {0}

private

Definition at line 113 of file VertexFittingTool.h.

{0};

m_seedVertexFitter

ToolHandle<Trk::IVertexFitter> Prompt::VertexFittingTool::m_seedVertexFitter

private

Initial value:

{
            this, "seedVertexFitterTool",
            "Trk::FastVertexFitter/FastVertexFitterTool"
        }

Definition at line 77 of file VertexFittingTool.h.

                                                        {
            this, "seedVertexFitterTool",
            "Trk::FastVertexFitter/FastVertexFitterTool"
        };

m_timer

TStopwatch Prompt::VertexFittingTool::m_timer

private

Definition at line 108 of file VertexFittingTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexFitter

ToolHandle<Trk::IVertexFitter> Prompt::VertexFittingTool::m_vertexFitter

private

Initial value:

{
            this, "vertexFitterTool", "Trk::FastVertexFitter/FastVertexFitterTool"
        }

Definition at line 74 of file VertexFittingTool.h.

                                                    {
            this, "vertexFitterTool", "Trk::FastVertexFitter/FastVertexFitterTool"
        };

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• VertexFittingTool.h
• VertexFittingTool.cxx