InDet::InDetIterativePriVxFinderTool Class Reference

#include <InDetIterativePriVxFinderTool.h>

Inheritance diagram for InDet::InDetIterativePriVxFinderTool:

Collaboration diagram for InDet::InDetIterativePriVxFinderTool:

Public Member Functions
	InDetIterativePriVxFinderTool (const std::string &t, const std::string &n, const IInterface *p)
	Constructor.
virtual	~InDetIterativePriVxFinderTool ()
	Destructor.
virtual StatusCode	initialize () override
virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * >	findVertex (const EventContext &ctx, const TrackCollection *trackTES) const override
	Finding method for Trk::Track collection.
virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * >	findVertex (const EventContext &ctx, const xAOD::TrackParticleContainer *trackParticles) const override
	Finding method for TrackParticle collection.
virtual StatusCode	finalize () 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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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 ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * >	findVertex (const EventContext &ctx, const std::vector< Trk::ITrackLink * > &trackVector) const
void	removeCompatibleTracks (xAOD::Vertex *myxAODVertex, std::vector< const Trk::TrackParameters * > &perigeesToFit, std::vector< Trk::ITrackLink * > &seedTracks) const
void	removeAllFrom (std::vector< const Trk::TrackParameters * > &perigeesToFit, std::vector< Trk::ITrackLink * > &seedTracks) const
double	compatibility (const Trk::TrackParameters &measPerigee, const xAOD::Vertex &vertex) const
void	printParameterSettings ()
	Internal method to print the parameters setting.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static void	countTracksAndNdf (xAOD::Vertex *myxAODVertex, double &ndf, int &ntracks)

Private Attributes
ToolHandle< Trk::IVertexFitter >	m_iVertexFitter
ToolHandle< InDet::IInDetTrackSelectionTool >	m_trkFilter
ToolHandle< Trk::IVertexSeedFinder >	m_SeedFinder
ToolHandle< Trk::IImpactPoint3dEstimator >	m_ImpactPoint3dEstimator
ToolHandle< Trk::IVertexLinearizedTrackFactory >	m_LinearizedTrackFactory
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey
BooleanProperty	m_useBeamConstraint {this, "useBeamConstraint", false}
DoubleProperty	m_significanceCutSeeding {this, "significanceCutSeeding", 10.}
DoubleProperty	m_maximumChi2cutForSeeding {this, "maximumChi2cutForSeeding", 36.}
IntegerProperty	m_maxVertices {this, "maxVertices", 25}
BooleanProperty	m_createSplitVertices {this, "createSplitVertices", false}
IntegerProperty	m_splitVerticesTrkInvFraction {this, "splitVerticesTrkInvFraction", 2, "inverse fraction to split tracks (1:N)"}
BooleanProperty	m_reassignTracksAfterFirstFit {this, "reassignTracksAfterFirstFit", false}
BooleanProperty	m_doMaxTracksCut {this, "doMaxTracksCut", false}
UnsignedIntegerProperty	m_maxTracks {this, "MaxTracks", 5000}
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

Author

Giacinto Piacquadio (Freiburg University)

This class provides an implementation for a primary vertex finding tool, which uses the Adaptive Vertex Fitter to reject outliers not belonging to the primary vertex interaction.

---

Changes:

David Shope david.nosp@m..ric.nosp@m.hard..nosp@m.shop.nosp@m.e@cer.nosp@m.n.ch (2016-04-26)

EDM Migration to xAOD - from Trk::VxCandidate to xAOD::Vertex

findVertex will now always return an xAOD::VertexContainer, even when using a TrackCollection or a TrackParticleBaseCollection as input.

Dave Casper dcasp.nosp@m.er@u.nosp@m.ci.ed.nosp@m.u (2018-03-28) Migrate beam spot service to conditions handle

Definition at line 68 of file InDetIterativePriVxFinderTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

InDetIterativePriVxFinderTool()

InDet::InDetIterativePriVxFinderTool::InDetIterativePriVxFinderTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Constructor.

Definition at line 47 of file InDetIterativePriVxFinderTool.cxx.

  : AthAlgTool(t, n, p)
{
  declareInterface<IVertexFinder>(this);
}

~InDetIterativePriVxFinderTool()

InDet::InDetIterativePriVxFinderTool::~InDetIterativePriVxFinderTool ( )

virtualdefault

Destructor.

Member Function Documentation

compatibility()

double InDet::InDetIterativePriVxFinderTool::compatibility ( const Trk::TrackParameters & measPerigee, const xAOD::Vertex & vertex ) const

private

Definition at line 813 of file InDetIterativePriVxFinderTool.cxx.

{
  Trk::LinearizedTrack* myLinearizedTrack =
    m_LinearizedTrackFactory->linearizedTrack(&measPerigee, vertex.position());
 
  AmgMatrix(2, 2) weightReduced =
    myLinearizedTrack->expectedCovarianceAtPCA().block<2, 2>(0, 0);
 
  AmgMatrix(2, 2) errorVertexReduced =
    (myLinearizedTrack->positionJacobian() *
     (vertex.covariancePosition() *
      myLinearizedTrack->positionJacobian().transpose()))
      .block<2, 2>(0, 0);
 
  weightReduced += errorVertexReduced;
 
  weightReduced = weightReduced.inverse().eval();
  Amg::Vector2D trackParameters2D =
    myLinearizedTrack->expectedParametersAtPCA().block<2, 1>(0, 0);
  double returnValue = trackParameters2D.dot(weightReduced * trackParameters2D);
 
  delete myLinearizedTrack;
  myLinearizedTrack = nullptr;
 
  return returnValue;
}

countTracksAndNdf()

void InDet::InDetIterativePriVxFinderTool::countTracksAndNdf ( xAOD::Vertex * myxAODVertex, double & ndf, int & ntracks )

staticprivate

Definition at line 883 of file InDetIterativePriVxFinderTool.cxx.

{
  if (myxAODVertex) {
    ndf = myxAODVertex->numberDoF();
 
    std::vector<Trk::VxTrackAtVertex> myVxTracksAtVtx =
      myxAODVertex->vxTrackAtVertex();
 
    std::vector<Trk::VxTrackAtVertex>::iterator tracksBegin =
      myVxTracksAtVtx.begin();
    std::vector<Trk::VxTrackAtVertex>::iterator tracksEnd =
      myVxTracksAtVtx.end();
 
    for (std::vector<Trk::VxTrackAtVertex>::iterator tracksIter = tracksBegin;
         tracksIter != tracksEnd;
         ++tracksIter) {
      if ((*tracksIter).weight() > 0.01) {
        ntracks += 1;
      }
    }
  }
}

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());
 
  }

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());
  }

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 InDet::InDetIterativePriVxFinderTool::finalize ( )

overridevirtual

Definition at line 798 of file InDetIterativePriVxFinderTool.cxx.

{
  return StatusCode::SUCCESS;
}

findVertex() [1/3]

std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > InDet::InDetIterativePriVxFinderTool::findVertex ( const EventContext & ctx, const std::vector< Trk::ITrackLink * > & trackVector ) const

private

Definition at line 224 of file InDetIterativePriVxFinderTool.cxx.

{
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{ m_beamSpotKey, ctx };
  const InDet::BeamSpotData* beamSpot = *beamSpotHandle;
  // two things need to be added
  // 1) the seeding mechanism
  // 2) the iterative removal of tracks
 
  std::vector<Trk::ITrackLink*> origTracks = trackVector;
  std::vector<Trk::ITrackLink*> seedTracks = trackVector;
 
  // TODO: xAODVertex_pair never seems to be used?
  std::vector<xAODVertex_pair> myxAODVertices;
 
  xAOD::VertexContainer* theVertexContainer = new xAOD::VertexContainer;
  xAOD::VertexAuxContainer* theVertexAuxContainer =
    new xAOD::VertexAuxContainer;
  theVertexContainer->setStore(theVertexAuxContainer);
 
  // bail out early with only Dummy vertex if multiplicity cut is applied and
  // exceeded
 
  if (m_doMaxTracksCut && (trackVector.size() > m_maxTracks)) {
    ATH_MSG_WARNING(trackVector.size()
                    << " tracks - exceeds maximum (" << m_maxTracks
                    << "), skipping vertexing and returning only dummy...");
    xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
    theVertexContainer->push_back(
      dummyxAODVertex); // have to add vertex to container here first so it can
                        // use its aux store
    dummyxAODVertex->setPosition(beamSpot->beamVtx().position());
    dummyxAODVertex->setCovariancePosition(
      beamSpot->beamVtx().covariancePosition());
    dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
    dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
    return std::make_pair(theVertexContainer, theVertexAuxContainer);
  }
 
  int iterations = 0;
  unsigned int seedtracknumber = seedTracks.size();
 
  // used to store seed info
  Amg::Vector3D actualVertex;
 
  // prepare iterators for tracks only necessary for seeding
  std::vector<Trk::ITrackLink*>::iterator seedBegin;
  std::vector<Trk::ITrackLink*>::iterator seedEnd;
 
  do {
 
    seedBegin = seedTracks.begin();
    seedEnd = seedTracks.end();
 
    if (seedtracknumber == 0) {
      ATH_MSG_DEBUG(" New iteration. No tracks available after track selection "
                    "for seeding. No finding done.");
      break;
    }
 
    ATH_MSG_DEBUG("ITERATION NUMBER " << iterations);
 
    // now find a new SEED
 
    std::vector<const Trk::TrackParameters*> perigeeList;
    for (std::vector<Trk::ITrackLink*>::iterator seedtrkAtVtxIter = seedBegin;
         seedtrkAtVtxIter != seedEnd;
         ++seedtrkAtVtxIter) {
      perigeeList.push_back((*seedtrkAtVtxIter)->parameters());
    }
 
    xAOD::Vertex theconstraint;
    if (m_useBeamConstraint && beamSpot != nullptr) {
      theconstraint =
        xAOD::Vertex(); // Default constructor creates a private store
      theconstraint.setPosition(beamSpot->beamVtx().position());
      theconstraint.setCovariancePosition(
        beamSpot->beamVtx().covariancePosition());
      theconstraint.setFitQuality(
        beamSpot->beamVtx().fitQuality().chiSquared(),
        beamSpot->beamVtx().fitQuality().doubleNumberDoF());
      actualVertex = m_SeedFinder->findSeed(perigeeList, &theconstraint);
    } else {
      actualVertex = m_SeedFinder->findSeed(perigeeList);
      Amg::MatrixX looseConstraintCovariance(3, 3);
      looseConstraintCovariance.setIdentity();
      looseConstraintCovariance = looseConstraintCovariance * 1e+8;
      theconstraint = xAOD::Vertex();
      theconstraint.setPosition(actualVertex);
      theconstraint.setCovariancePosition(looseConstraintCovariance);
      theconstraint.setFitQuality(0., -3.);
    }
 
    if (msgLvl(MSG::DEBUG)) {
      msg(MSG::DEBUG) << " seed at x: " << actualVertex.x()
                      << " at y: " << actualVertex.y()
                      << " at z: " << actualVertex.z() << endmsg;
    }
 
    if (actualVertex.z() == 0.) {
      break;
    }
 
    // now question (remove tracks which are too far away??? I think so...)
    std::vector<const Trk::TrackParameters*> perigeesToFit;
    std::vector<const Trk::TrackParameters*> perigeesToFitSplitVertex;
 
    int numberOfTracks(perigeeList.size());
 
    std::vector<const Trk::TrackParameters*>::const_iterator perigeeListBegin =
      perigeeList.begin();
    std::vector<const Trk::TrackParameters*>::const_iterator perigeeListEnd =
      perigeeList.end();
 
    int counter = 0;
 
    for (std::vector<const Trk::TrackParameters*>::const_iterator
           perigeeListIter = perigeeListBegin;
         perigeeListIter != perigeeListEnd;
         ++perigeeListIter) {
      if (numberOfTracks <= 2) {
        perigeesToFit.push_back(*perigeeListIter);
        counter += 1;
      } else if (numberOfTracks <= 4 && !m_createSplitVertices) {
        perigeesToFit.push_back(*perigeeListIter);
        counter += 1;
      } else if (numberOfTracks <= 4 * m_splitVerticesTrkInvFraction &&
                 m_createSplitVertices) {
        // few tracks are left, put them into the fit regardless their position!
        if (counter % m_splitVerticesTrkInvFraction == 0) {
          perigeesToFit.push_back(*perigeeListIter);
          counter += 1;
        } else {
          perigeesToFitSplitVertex.push_back(*perigeeListIter);
          counter += 1;
        }
      } else { // check first whether it is not too far away!
        double distance = 0.;
        try {
          std::unique_ptr<Trk::PlaneSurface> mySurface =
            m_ImpactPoint3dEstimator->Estimate3dIP(
              *perigeeListIter, &actualVertex, distance);
        } catch (error::ImpactPoint3dEstimatorProblem err) {
          msg(MSG::WARNING) << " ImpactPoint3dEstimator failed to find minimum "
                               "distance between track and vertex seed: "
                            << err.p << endmsg;
        }
 
        if (distance < 0) {
          msg(MSG::WARNING)
            << " Distance between track and seed vtx is negative: " << distance
            << endmsg;
        }
 
        const Trk::TrackParameters* myPerigee = (*perigeeListIter);
 
        // very approximate error
        double error = 0.;
 
        if (myPerigee && myPerigee->covariance()) {
          error = std::sqrt((*myPerigee->covariance())(Trk::d0, Trk::d0) +
                            (*myPerigee->covariance())(Trk::z0, Trk::z0));
        } // end of the security check
 
        if (error == 0.) {
          msg(MSG::ERROR) << " Error is zero! " << distance << endmsg;
          error = 1.;
        }
 
        if (distance / error < m_significanceCutSeeding) {
          if (counter % m_splitVerticesTrkInvFraction == 0 ||
              !m_createSplitVertices) {
            perigeesToFit.push_back(*perigeeListIter);
            counter += 1;
          } else {
            perigeesToFitSplitVertex.push_back(*perigeeListIter);
            counter += 1;
          }
        }
      }
    }
 
    if (perigeesToFit.empty()) {
      ATH_MSG_DEBUG(" No good seed found. Exiting search for vertices...");
      break;
    }
 
    // now you have perigeeToFit and perigeeToFitSplitVertices
    // AND HERE YOU DO THE FIT
    // to reassign vertices you look ino what is already in myVxCandidate
    // you do it only ONCE!
 
    xAOD::Vertex* myxAODVertex = nullptr;
    xAOD::Vertex* myxAODSplitVertex = nullptr;
 
    if (m_useBeamConstraint && !perigeesToFit.empty()) {
      myxAODVertex = m_iVertexFitter->fit(perigeesToFit, theconstraint);
    } else if (!m_useBeamConstraint && perigeesToFit.size() > 1) {
      myxAODVertex = m_iVertexFitter->fit(perigeesToFit);
    }
    if (m_createSplitVertices && perigeesToFitSplitVertex.size() > 1) {
      myxAODSplitVertex = m_iVertexFitter->fit(perigeesToFitSplitVertex);
    }
 
    double ndf = 0.;
    int ntracks = 0;
    countTracksAndNdf(myxAODVertex, ndf, ntracks);
 
    double ndfSplitVertex = 0.;
    int ntracksSplitVertex = 0;
    countTracksAndNdf(myxAODSplitVertex, ndfSplitVertex, ntracksSplitVertex);
 
    bool goodVertex = myxAODVertex != nullptr &&
                      ((!m_useBeamConstraint && ndf > 0 && ntracks >= 2) ||
                       (m_useBeamConstraint && ndf > 3 && ntracks >= 2));
 
    if (msgLvl(MSG::DEBUG)) {
      msg(MSG::DEBUG) << " xAOD::Vertex is pointer: " << myxAODVertex
                      << " ndf = " << ndf << " ntracks (with weight>0.01) "
                      << ntracks << " beam constraint "
                      << (m_useBeamConstraint ? "yes" : "no") << endmsg;
    }
 
    if (!goodVertex) {
      removeAllFrom(perigeesToFit, seedTracks);
    } else {
      if (m_reassignTracksAfterFirstFit && (!m_createSplitVertices)) {
        // now you HAVE a good vertex
        // but you want to add the tracks which you missed...
 
        int numberOfAddedTracks = 0;
 
        // iterate on remaining vertices and cross-check if tracks need to be
        // attached to new vertex
        xAOD::VertexContainer::iterator vxBegin = theVertexContainer->begin();
        xAOD::VertexContainer::iterator vxEnd = theVertexContainer->end();
 
        for (xAOD::VertexContainer::iterator vxIter = vxBegin; vxIter != vxEnd;
             ++vxIter) {
          // now iterate on tracks at vertex
 
          std::vector<Trk::VxTrackAtVertex>* myVxTracksAtVtx =
            (&(*vxIter)->vxTrackAtVertex());
 
          if (!myVxTracksAtVtx)
            continue;
 
          std::vector<Trk::VxTrackAtVertex>::iterator tracksBegin =
            myVxTracksAtVtx->begin();
          std::vector<Trk::VxTrackAtVertex>::iterator tracksEnd =
            myVxTracksAtVtx->end();
 
          for (std::vector<Trk::VxTrackAtVertex>::iterator tracksIter =
                 tracksBegin;
               tracksIter != tracksEnd;) {
            // only try with tracks which are not too tightly assigned to
            // another vertex
            if ((*tracksIter).weight() > 0.01) {
              ++tracksIter;
              continue;
            }
 
            const Trk::TrackParameters* trackPerigee =
              (*tracksIter).initialPerigee();
 
            if (trackPerigee == nullptr) {
              ATH_MSG_ERROR("Cast to perigee gives null pointer");
              return std::make_pair(theVertexContainer, theVertexAuxContainer);
            }
 
            double chi2_newvtx = compatibility(*trackPerigee, *myxAODVertex);
            double chi2_oldvtx = compatibility(*trackPerigee, *(*vxIter));
 
            bool remove = false;
 
            if (chi2_newvtx < chi2_oldvtx) {
              ATH_MSG_DEBUG(" Found track of old vertex (chi2= "
                            << chi2_oldvtx
                            << ") more compatible to new one (chi2= "
                            << chi2_newvtx << ")");
 
              perigeesToFit.push_back(trackPerigee);
              // but you need to re-add it to the seedTracks too...
 
              bool isFound = false;
 
              std::vector<Trk::ITrackLink*>::iterator origBegin =
                origTracks.begin();
              std::vector<Trk::ITrackLink*>::iterator origEnd =
                origTracks.end();
 
              for (std::vector<Trk::ITrackLink*>::iterator origIter = origBegin;
                   origIter != origEnd;
                   ++origIter) {
                if ((*origIter)->parameters() == trackPerigee) {
                  isFound = true;
                  seedTracks.push_back(*origIter);
                  break;
                }
              }
              if (!isFound) {
                ATH_MSG_WARNING(" Cannot find old perigee to re-add back to "
                                "seed tracks... ");
              }
 
              numberOfAddedTracks += 1;
 
              remove = true;
            }
 
            if (remove) {
              // now you have to delete the track from the old vertex...
              // easy???
              tracksIter = myVxTracksAtVtx->erase(tracksIter);
              tracksBegin = myVxTracksAtVtx->begin();
              tracksEnd = myVxTracksAtVtx->end();
            } else {
              ++tracksIter;
            }
          } // end of iterating on tracks
        }   // end of iterating on already found vertices in event
 
        // now you have to delete the previous xAOD::Vertex, do a new fit, then
        // check if you still have a good vertex
 
        if (numberOfAddedTracks > 0) {
          delete myxAODVertex;
          myxAODVertex = nullptr;
 
          if (m_useBeamConstraint && !perigeesToFit.empty()) {
            myxAODVertex = m_iVertexFitter->fit(perigeesToFit, theconstraint);
          } else if (!m_useBeamConstraint && perigeesToFit.size() > 1) {
            myxAODVertex = m_iVertexFitter->fit(perigeesToFit);
          }
 
          ndf = 0.;
          ntracks = 0;
          countTracksAndNdf(myxAODVertex, ndf, ntracks);
 
          goodVertex = myxAODVertex != nullptr &&
                       ((!m_useBeamConstraint && ndf > 0 && ntracks >= 2) ||
                        (m_useBeamConstraint && ndf > 3 && ntracks >= 2));
 
          ATH_MSG_DEBUG(" Refitted xAODVertex is pointer: "
                        << myxAODVertex << " ndf = " << ndf
                        << " ntracks (with weight>0.01) " << ntracks
                        << " beam constraint "
                        << (m_useBeamConstraint ? "yes" : "no"));
 
          if (!goodVertex) {
            removeAllFrom(perigeesToFit, seedTracks);
            ATH_MSG_DEBUG(" Adding tracks resulted in an invalid vertex. "
                          "Should be rare. ");
          }
        } // end if tracks were added...
      }   // end reassign tracks from previous vertices and refitting if needed
 
      // need to re-ask goodVertex since it can be changed in the mean time
      if (goodVertex) {
        removeCompatibleTracks(myxAODVertex, perigeesToFit, seedTracks);
      }
    } // end else case on if not good Vertex
 
    bool goodSplitVertex = false;
 
    if (m_createSplitVertices) {
      goodSplitVertex = myxAODSplitVertex != nullptr && ndfSplitVertex > 0 &&
                        ntracksSplitVertex >= 2;
 
      ATH_MSG_DEBUG(" xAODSplitVertex is pointer: "
                    << myxAODSplitVertex << " ndf = " << ndfSplitVertex
                    << " ntracks (with weight>0.01) " << ntracksSplitVertex);
 
      if (!goodSplitVertex) {
        removeAllFrom(perigeesToFitSplitVertex, seedTracks);
      } else {
        removeCompatibleTracks(
          myxAODSplitVertex, perigeesToFitSplitVertex, seedTracks);
 
      } // end else if not good Vertex
    }   // end if create split vertices
 
    if (!m_createSplitVertices) {
      if (goodVertex) {
        theVertexContainer->push_back(myxAODVertex);
      } else {
        if (myxAODVertex) {
          delete myxAODVertex;
          myxAODVertex = nullptr;
        }
      }
    } else {
      if (goodVertex) {
        // type does not seem to be set earlier
        myxAODVertex->setVertexType(xAOD::VxType::PriVtx);
        theVertexContainer->push_back(myxAODVertex);
      } else {
        if (myxAODVertex) {
          delete myxAODVertex;
          myxAODVertex = nullptr;
        }
 
        xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
        theVertexContainer->push_back(
          dummyxAODVertex); // have to add vertex to container here first so it
                            // can use its aux store
        dummyxAODVertex->setPosition(beamSpot->beamVtx().position());
        dummyxAODVertex->setCovariancePosition(
          beamSpot->beamVtx().covariancePosition());
        dummyxAODVertex->vxTrackAtVertex() =
          std::vector<Trk::VxTrackAtVertex>();
        dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
      }
      if (goodSplitVertex) {
        // type does not seem to be set earlier
        myxAODSplitVertex->setVertexType(xAOD::VxType::PriVtx);
        theVertexContainer->push_back(myxAODSplitVertex);
      } else {
        if (myxAODSplitVertex) {
          delete myxAODSplitVertex;
          myxAODSplitVertex = nullptr;
        }
 
        xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
        theVertexContainer->push_back(
          dummyxAODVertex); // have to add vertex to container here first so it
                            // can use its aux store
        dummyxAODVertex->setPosition(beamSpot->beamVtx().position());
        dummyxAODVertex->setCovariancePosition(
          beamSpot->beamVtx().covariancePosition());
        dummyxAODVertex->vxTrackAtVertex() =
          std::vector<Trk::VxTrackAtVertex>();
        dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
      }
    }
 
    ++iterations;
  } while (seedTracks.size() > 1 && iterations < m_maxVertices);
 
  if (iterations == m_maxVertices) {
    ATH_MSG_DEBUG("Reached maximum iterations, have "<<iterations<<" vertices");
  }
  else if (iterations > m_maxVertices) {
    ATH_MSG_WARNING("Exceeded maximum iterations, have "<<iterations<<" vertices, m_maxVertices = "<<m_maxVertices);
  }
 
  //---- add dummy vertex at the end
  //------------------------------------------------------//
  //---- if one or more vertices are already there: let dummy have same position
  // as primary vertex
  if (!m_createSplitVertices) {
    if (!theVertexContainer->empty()) {
      xAOD::Vertex* primaryVtx = theVertexContainer->front();
      if (!primaryVtx->vxTrackAtVertex().empty()) {
        primaryVtx->setVertexType((xAOD::VxType::VertexType)Trk::PriVtx);
        xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
        theVertexContainer->push_back(
          dummyxAODVertex); // have to add vertex to container here first so it
                            // can use its aux store
        dummyxAODVertex->setPosition(primaryVtx->position());
        dummyxAODVertex->setCovariancePosition(
          primaryVtx->covariancePosition());
        dummyxAODVertex->vxTrackAtVertex() =
          std::vector<Trk::VxTrackAtVertex>();
        dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
      } else {
        primaryVtx->setVertexType(xAOD::VxType::NoVtx);
      }
    }
    //---- if no vertex is there let dummy be at beam spot
 
    else if (theVertexContainer->empty()) {
      xAOD::Vertex* dummyxAODVertex = new xAOD::Vertex;
      theVertexContainer->push_back(
        dummyxAODVertex); // have to add vertex to container here first so it
                          // can use its aux store
      dummyxAODVertex->setPosition(beamSpot->beamVtx().position());
      dummyxAODVertex->setCovariancePosition(
        beamSpot->beamVtx().covariancePosition());
      dummyxAODVertex->vxTrackAtVertex() = std::vector<Trk::VxTrackAtVertex>();
      dummyxAODVertex->setVertexType(xAOD::VxType::NoVtx);
    }
    // loop over the pile up to set it as pile up (EXCLUDE first and last
    // vertex, do not do that in split mode)
    for (unsigned int i = 0; i < theVertexContainer->size() - 1; i++) {
 
      ATH_MSG_DEBUG(
        " Vtx: " << i << " x= " << (*theVertexContainer)[i]->position().x()
                 << " y= " << (*theVertexContainer)[i]->position().y() << " z= "
                 << (*theVertexContainer)[i]->position().z() << " ntracks= "
                 << (*theVertexContainer)[i]->vxTrackAtVertex().size()
                 << " chi2= " << (*theVertexContainer)[i]->chiSquared()
                 << " ndf = " << (*theVertexContainer)[i]->numberDoF());
      if (i > 0) {
        (*theVertexContainer)[i]->setVertexType(xAOD::VxType::PileUp);
      }
    }
  }
 
  xAOD::VertexContainer::iterator vxBegin = theVertexContainer->begin();
  xAOD::VertexContainer::iterator vxEnd = theVertexContainer->end();
 
  // prepare iterators for tracks only necessary for seeding
  std::vector<Trk::ITrackLink*>::iterator origtrkbegin = origTracks.begin();
  std::vector<Trk::ITrackLink*>::iterator origtrkend = origTracks.end();
 
  for (xAOD::VertexContainer::iterator vxIter = vxBegin; vxIter != vxEnd;
       ++vxIter) {
    std::vector<Trk::VxTrackAtVertex>* myVxTracksAtVtx =
      &((*vxIter)->vxTrackAtVertex());
 
    if (!myVxTracksAtVtx)
      continue;
 
    std::vector<Trk::VxTrackAtVertex>::iterator tracksBegin =
      myVxTracksAtVtx->begin();
    std::vector<Trk::VxTrackAtVertex>::iterator tracksEnd =
      myVxTracksAtVtx->end();
 
    bool found = false;
 
    for (std::vector<Trk::VxTrackAtVertex>::iterator tracksIter = tracksBegin;
         tracksIter != tracksEnd;
         ++tracksIter) {
 
      // now look for corresponding ITrackLink
      for (std::vector<Trk::ITrackLink*>::iterator origtrkiter = origtrkbegin;
           origtrkiter != origtrkend;
           ++origtrkiter) {
        if ((*origtrkiter)->parameters() == (*tracksIter).initialPerigee()) {
          found = true;
 
          // assigning the input track to the fitted vertex through
          // VxTrackAtVertices vector
          (*tracksIter).setOrigTrack(*origtrkiter);
 
          // See if the trklink is to an xAOD::TrackParticle
          Trk::LinkToXAODTrackParticle* linkToXAODTP = nullptr;
          Trk::ITrackLink* tmpLink = (*tracksIter).trackOrParticleLink();
          if (tmpLink->type() == Trk::ITrackLink::ToxAODTrackParticle) {
            linkToXAODTP = static_cast<Trk::LinkToXAODTrackParticle*>(tmpLink);
          }
 
          // If track is an xAOD::TrackParticle, set directly in xAOD::Vertex
          if (linkToXAODTP) {
            (*vxIter)->addTrackAtVertex(*linkToXAODTP, (*tracksIter).weight());
          }
 
          origTracks.erase(origtrkiter);
          origtrkbegin = origTracks.begin();
          origtrkend = origTracks.end();
          break;
        }
      }
      if (!found) {
        ATH_MSG_ERROR(" Cannot find vector element to fix links (step 4)! ");
      }
    } // end iterate on tracks at vtx
  }   // end iterate on vertices
 
  for (std::vector<Trk::ITrackLink*>::iterator origtrkiter = origtrkbegin;
       origtrkiter != origtrkend;
       ++origtrkiter) {
    if ((*origtrkiter) != 0) {
      delete *origtrkiter;
      *origtrkiter = 0;
    }
  }
 
  return std::make_pair(theVertexContainer, theVertexAuxContainer);
}

findVertex() [2/3]

std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > InDet::InDetIterativePriVxFinderTool::findVertex ( const EventContext & ctx, const TrackCollection * trackTES ) const

overridevirtual

Finding method for Trk::Track collection.

Implements InDet::IVertexFinder.

Definition at line 119 of file InDetIterativePriVxFinderTool.cxx.

{
 
  ATH_MSG_DEBUG(
    " Number of input tracks before track selection: " << trackTES->size());
 
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{ m_beamSpotKey, ctx };
  const InDet::BeamSpotData* beamSpot = *beamSpotHandle;
 
  std::vector<Trk::ITrackLink*> selectedTracks;
 
  using TrackDataVecIter = DataVector<Trk::Track>::const_iterator;
 
  bool selectionPassed;
  for (TrackDataVecIter itr = (*trackTES).begin(); itr != (*trackTES).end();
       ++itr) {
 
    if (m_useBeamConstraint && beamSpot != nullptr) {
      Trk::RecVertex beamPosition{ beamSpot->beamVtx() };
      selectionPassed =
        static_cast<bool>(m_trkFilter->accept(**itr, &beamPosition));
    } else {
      Trk::Vertex null(Amg::Vector3D(0, 0, 0));
      selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &null));
    }
    if (selectionPassed) {
      ElementLink<TrackCollection> link;
      link.setElement(*itr);
      Trk::LinkToTrack* linkTT = new Trk::LinkToTrack(link);
      linkTT->setStorableObject(*trackTES);
      selectedTracks.push_back(linkTT);
    }
  }
 
  ATH_MSG_DEBUG("Of " << trackTES->size() << " tracks " << selectedTracks.size()
                      << " survived the preselection.");
 
  std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
    returnContainers = findVertex(ctx, selectedTracks);
 
  return returnContainers;
}

findVertex() [3/3]

std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > InDet::InDetIterativePriVxFinderTool::findVertex ( const EventContext & ctx, const xAOD::TrackParticleContainer * trackParticles ) const

overridevirtual

Finding method for TrackParticle collection.

Implements InDet::IVertexFinder.

Definition at line 164 of file InDetIterativePriVxFinderTool.cxx.

{
  ATH_MSG_DEBUG(" Number of input tracks before track selection: "
                << trackParticles->size());
 
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{ m_beamSpotKey, ctx };
  const InDet::BeamSpotData* beamSpot = *beamSpotHandle;
 
  std::vector<Trk::ITrackLink*> selectedTracks;
 
  using TrackParticleDataVecIter =
    DataVector<xAOD::TrackParticle>::const_iterator;
 
  bool selectionPassed;
  for (TrackParticleDataVecIter itr = trackParticles->begin();
       itr != trackParticles->end();
       ++itr) {
 
    if (m_useBeamConstraint && beamSpot != nullptr) {
      xAOD::Vertex beamPosition;
      beamPosition.makePrivateStore();
      beamPosition.setPosition(beamSpot->beamVtx().position());
      beamPosition.setCovariancePosition(
        beamSpot->beamVtx().covariancePosition());
      selectionPassed =
        static_cast<bool>(m_trkFilter->accept(**itr, &beamPosition));
    } else {
 
      xAOD::Vertex null;
      null.makePrivateStore();
      null.setPosition(Amg::Vector3D(0, 0, 0));
      AmgSymMatrix(3) vertexError;
      vertexError.setZero();
      null.setCovariancePosition(vertexError);
      selectionPassed = static_cast<bool>(m_trkFilter->accept(**itr, &null));
    }
 
    if (selectionPassed) {
      ElementLink<xAOD::TrackParticleContainer> link;
      link.setElement(*itr);
      Trk::LinkToXAODTrackParticle* linkTT =
        new Trk::LinkToXAODTrackParticle(link);
      linkTT->setStorableObject(*trackParticles);
      selectedTracks.push_back(linkTT);
    }
  }
 
  ATH_MSG_DEBUG("Of " << trackParticles->size() << " tracks "
                      << selectedTracks.size()
                      << " survived the preselection.");
 
  std::pair<xAOD::VertexContainer*, xAOD::VertexAuxContainer*>
    returnContainers = findVertex(ctx, selectedTracks);
 
  return returnContainers;
}

initialize()

StatusCode InDet::InDetIterativePriVxFinderTool::initialize ( )

overridevirtual

Definition at line 59 of file InDetIterativePriVxFinderTool.cxx.

{
  if (m_createSplitVertices && m_useBeamConstraint) {
    ATH_MSG_FATAL(" Split vertices cannot be obtained if beam spot constraint "
                  "is true! Change settings...");
    return StatusCode::FAILURE;
  }
 
  /* Get the right vertex fitting tool from ToolSvc */
  if (m_iVertexFitter.retrieve().isFailure()) {
    ATH_MSG_FATAL("Failed to retrieve tool " << m_iVertexFitter);
    return StatusCode::FAILURE;
  }
 
  if (m_SeedFinder.retrieve().isFailure()) {
    ATH_MSG_FATAL("Failed to retrieve tool " << m_SeedFinder);
    return StatusCode::FAILURE;
  }
 
  if (m_LinearizedTrackFactory.retrieve().isFailure()) {
    ATH_MSG_FATAL("Failed to retrieve tool " << m_LinearizedTrackFactory);
    return StatusCode::FAILURE;
  }
 
  if (m_ImpactPoint3dEstimator.retrieve().isFailure()) {
    ATH_MSG_FATAL("Failed to retrieve tool " << m_ImpactPoint3dEstimator);
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK(m_beamSpotKey.initialize());
 
  if (m_trkFilter.retrieve().isFailure()) {
    ATH_MSG_ERROR(" Unable to retrieve " << m_trkFilter);
    return StatusCode::FAILURE;
  }
 
  // since some parameters special to an inherited class this method
  // will be overloaded by the inherited class
  printParameterSettings();
 
  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.

interfaceID()

const InterfaceID & InDet::IVertexFinder::interfaceID ( )

inlinestaticinherited

Definition at line 56 of file IVertexFinder.h.

{ return IID_IVertexFinder; }

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.

printParameterSettings()

void InDet::InDetIterativePriVxFinderTool::printParameterSettings ( )

private

Internal method to print the parameters setting.

Definition at line 804 of file InDetIterativePriVxFinderTool.cxx.

{
  ATH_MSG_DEBUG("VxPrimary initialize(): Parametersettings "
               << '\n'
               << "VertexFitter " << m_iVertexFitter << '\n');
}

removeAllFrom()

void InDet::InDetIterativePriVxFinderTool::removeAllFrom ( std::vector< const Trk::TrackParameters * > & perigeesToFit, std::vector< Trk::ITrackLink * > & seedTracks ) const

private

Definition at line 843 of file InDetIterativePriVxFinderTool.cxx.

{
  // remove all perigeesToFit and go on...
 
  std::vector<Trk::ITrackLink*>::iterator seedBegin = seedTracks.begin();
  std::vector<Trk::ITrackLink*>::iterator seedEnd = seedTracks.end();
 
  std::vector<const Trk::TrackParameters*>::iterator perigeesToFitBegin =
    perigeesToFit.begin();
  std::vector<const Trk::TrackParameters*>::iterator perigeesToFitEnd =
    perigeesToFit.end();
 
  for (std::vector<const Trk::TrackParameters*>::iterator perigeesToFitIter =
         perigeesToFitBegin;
       perigeesToFitIter != perigeesToFitEnd;
       ++perigeesToFitIter) {
 
    bool found = false;
 
    for (std::vector<Trk::ITrackLink*>::iterator seedIter = seedTracks.begin();
         seedIter != seedEnd;
         ++seedIter) {
      if ((*seedIter)->parameters() == *perigeesToFitIter) {
        found = true;
        seedTracks.erase(seedIter);
        seedBegin = seedTracks.begin();
        seedEnd = seedTracks.end();
        break;
      }
    }
    if (!found) {
      ATH_MSG_ERROR(
        " Cannot find vector element to delete when removing BAD vertex! ");
    }
  } // for cycle
}

removeCompatibleTracks()

void InDet::InDetIterativePriVxFinderTool::removeCompatibleTracks ( xAOD::Vertex * myxAODVertex, std::vector< const Trk::TrackParameters * > & perigeesToFit, std::vector< Trk::ITrackLink * > & seedTracks ) const

private

Definition at line 909 of file InDetIterativePriVxFinderTool.cxx.

{
  // now you have your new vertex with its new tracks
  // now you have to get the compatibility also of all tracks which DIDN'T
  // BELONG to the vertex!
  std::vector<Trk::VxTrackAtVertex>* tracksAtVertex =
    &(myxAODVertex->vxTrackAtVertex());
 
  std::vector<Trk::VxTrackAtVertex>::const_iterator tracksAtVertexBegin =
    tracksAtVertex->begin();
  std::vector<Trk::VxTrackAtVertex>::const_iterator tracksAtVertexEnd =
    tracksAtVertex->end();
 
  std::vector<Trk::ITrackLink*>::iterator seedBegin = seedTracks.begin();
  std::vector<Trk::ITrackLink*>::iterator seedEnd = seedTracks.end();
 
  std::vector<const Trk::TrackParameters*>::iterator perigeesToFitBegin =
    perigeesToFit.begin();
  std::vector<const Trk::TrackParameters*>::iterator perigeesToFitEnd =
    perigeesToFit.end();
 
  for (std::vector<Trk::VxTrackAtVertex>::const_iterator tracksAtVertexIter =
         tracksAtVertexBegin;
       tracksAtVertexIter != tracksAtVertexEnd;
       ++tracksAtVertexIter) {
 
    bool found = false;
 
    for (std::vector<Trk::ITrackLink*>::iterator seedIter = seedBegin;
         seedIter != seedEnd;
         ++seedIter) {
      if ((*seedIter)->parameters() == (*tracksAtVertexIter).initialPerigee()) {
        found = true;
        if ((*tracksAtVertexIter).weight() > 0.01) {
          seedTracks.erase(seedIter);
          seedBegin = seedTracks.begin();
          seedEnd = seedTracks.end();
        }
        break;
      }
    }
 
    if (!found) {
      ATH_MSG_ERROR(" Cannot find vector element to delete (step 1)! ");
    }
 
    found = false;
    for (std::vector<const Trk::TrackParameters*>::iterator perigeesToFitIter =
           perigeesToFitBegin;
         perigeesToFitIter != perigeesToFitEnd;
         ++perigeesToFitIter) {
      if (*perigeesToFitIter == (*tracksAtVertexIter).initialPerigee()) {
        found = true;
        if ((*tracksAtVertexIter).weight() > 0.01) {
          perigeesToFit.erase(perigeesToFitIter);
          perigeesToFitBegin = perigeesToFit.begin();
          perigeesToFitEnd = perigeesToFit.end();
        }
        break;
      }
    }
 
    if (!found) {
      ATH_MSG_ERROR(" Cannot find vector element to delete (step 2)! ");
    }
  } // finishing iterating on tracks at vertex
 
  std::vector<Trk::VxTrackAtVertex>* myVxTracksAtVertex =
    &(myxAODVertex->vxTrackAtVertex());
 
  std::vector<Trk::VxTrackAtVertex>::iterator tracksBegin =
    myVxTracksAtVertex->begin();
  std::vector<Trk::VxTrackAtVertex>::iterator tracksEnd =
    myVxTracksAtVertex->end();
 
  for (std::vector<const Trk::TrackParameters*>::iterator perigeesToFitIter =
         perigeesToFitBegin;
       perigeesToFitIter != perigeesToFitEnd;
       ++perigeesToFitIter) {
    bool found = false;
 
    // compute the chi2 with respect to the last fitted vertex!
    //(easy since track was NOT used in the last vertex fit...)
 
    const Trk::TrackParameters* myPerigee = (*perigeesToFitIter);
 
    if (myPerigee == nullptr) {
      ATH_MSG_ERROR(" nullptr to perigee ");
      return;
    }
 
    double chi2 = compatibility(*myPerigee, *myxAODVertex);
 
    // check if still sufficiently compatible to previous vertex
    //(CAN BE VERY LOOSE TO BE CONSERVATIVE AGAINST FAR OUTLIERS)
    if (chi2 < m_maximumChi2cutForSeeding) {
      for (std::vector<Trk::ITrackLink*>::iterator seedIter =
             seedTracks.begin();
           seedIter != seedEnd;
           ++seedIter) {
        if ((*seedIter)->parameters() == *perigeesToFitIter) {
          found = true;
          seedTracks.erase(seedIter);
          seedBegin = seedTracks.begin();
          seedEnd = seedTracks.end();
          break;
        }
      }
 
      if (!found) {
        ATH_MSG_ERROR(" Cannot find vector element to delete (step 3)! ");
      }
    } else {
      // look if the track is attached to the vertex. If this is the case you
      // should delete the track from the vertex!
      for (std::vector<Trk::VxTrackAtVertex>::iterator tracksIter = tracksBegin;
           tracksIter != tracksEnd;
           ++tracksIter) {
        if ((*tracksIter).initialPerigee() == *perigeesToFitIter) {
          // delete *tracksIter;
          // delete has to happen BEFORE the erase (because the iterator will
          // point to the next object in the vector AFTER the erase!)
          myVxTracksAtVertex->erase(tracksIter);
          tracksBegin = myVxTracksAtVertex->begin();
          tracksEnd = myVxTracksAtVertex->end();
          found = true;
          break;
        }
      }
    }
  } // iterate on all perigeesToFit
}

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_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> InDet::InDetIterativePriVxFinderTool::m_beamSpotKey

private

Initial value:

{
    this,
    "BeamSpotKey",
    "BeamSpotData",
    "SG key for beam spot"
  }

Definition at line 149 of file InDetIterativePriVxFinderTool.h.

                                                      {
    this,
    "BeamSpotKey",
    "BeamSpotData",
    "SG key for beam spot"
  };

m_createSplitVertices

BooleanProperty InDet::InDetIterativePriVxFinderTool::m_createSplitVertices {this, "createSplitVertices", false}

private

Definition at line 163 of file InDetIterativePriVxFinderTool.h.

{this, "createSplitVertices", false};

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_doMaxTracksCut

BooleanProperty InDet::InDetIterativePriVxFinderTool::m_doMaxTracksCut {this, "doMaxTracksCut", false}

private

Definition at line 170 of file InDetIterativePriVxFinderTool.h.

{this, "doMaxTracksCut", 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_ImpactPoint3dEstimator

ToolHandle<Trk::IImpactPoint3dEstimator> InDet::InDetIterativePriVxFinderTool::m_ImpactPoint3dEstimator

private

Initial value:

{
    this,
    "ImpactPoint3dEstimator",
    "Trk::ImpactPoint3dEstimator"
  }

Definition at line 137 of file InDetIterativePriVxFinderTool.h.

                                                                 {
    this,
    "ImpactPoint3dEstimator",
    "Trk::ImpactPoint3dEstimator"
  };

m_iVertexFitter

ToolHandle<Trk::IVertexFitter> InDet::InDetIterativePriVxFinderTool::m_iVertexFitter

private

Initial value:

{ this,
                                                  "VertexFitterTool",
                                                  "Trk::AdaptiveVertexFitter" }

Definition at line 125 of file InDetIterativePriVxFinderTool.h.

                                              { this,
                                                  "VertexFitterTool",
                                                  "Trk::AdaptiveVertexFitter" };

m_LinearizedTrackFactory

ToolHandle<Trk::IVertexLinearizedTrackFactory> InDet::InDetIterativePriVxFinderTool::m_LinearizedTrackFactory

private

Initial value:

{
    this,
    "LinearizedTrackFactory",
    "Trk::FullLinearizedTrackFactory"
  }

Definition at line 143 of file InDetIterativePriVxFinderTool.h.

                                                                       {
    this,
    "LinearizedTrackFactory",
    "Trk::FullLinearizedTrackFactory"
  };

m_maximumChi2cutForSeeding

DoubleProperty InDet::InDetIterativePriVxFinderTool::m_maximumChi2cutForSeeding {this, "maximumChi2cutForSeeding", 36.}

private

Definition at line 159 of file InDetIterativePriVxFinderTool.h.

{this, "maximumChi2cutForSeeding", 36.};

m_maxTracks

UnsignedIntegerProperty InDet::InDetIterativePriVxFinderTool::m_maxTracks {this, "MaxTracks", 5000}

private

Definition at line 171 of file InDetIterativePriVxFinderTool.h.

{this, "MaxTracks", 5000};

m_maxVertices

IntegerProperty InDet::InDetIterativePriVxFinderTool::m_maxVertices {this, "maxVertices", 25}

private

Definition at line 161 of file InDetIterativePriVxFinderTool.h.

{this, "maxVertices", 25};

m_reassignTracksAfterFirstFit

BooleanProperty InDet::InDetIterativePriVxFinderTool::m_reassignTracksAfterFirstFit {this, "reassignTracksAfterFirstFit", false}

private

Definition at line 167 of file InDetIterativePriVxFinderTool.h.

{this, "reassignTracksAfterFirstFit", false};

m_SeedFinder

ToolHandle<Trk::IVertexSeedFinder> InDet::InDetIterativePriVxFinderTool::m_SeedFinder

private

Initial value:

{ this,
                                                   "SeedFinder",
                                                   "Trk::ZScanSeedFinder" }

Definition at line 134 of file InDetIterativePriVxFinderTool.h.

                                               { this,
                                                   "SeedFinder",
                                                   "Trk::ZScanSeedFinder" };

m_significanceCutSeeding

DoubleProperty InDet::InDetIterativePriVxFinderTool::m_significanceCutSeeding {this, "significanceCutSeeding", 10.}

private

Definition at line 157 of file InDetIterativePriVxFinderTool.h.

{this, "significanceCutSeeding", 10.};

m_splitVerticesTrkInvFraction

IntegerProperty InDet::InDetIterativePriVxFinderTool::m_splitVerticesTrkInvFraction {this, "splitVerticesTrkInvFraction", 2, "inverse fraction to split tracks (1:N)"}

private

Definition at line 164 of file InDetIterativePriVxFinderTool.h.

{this, "splitVerticesTrkInvFraction", 2, "inverse fraction to split tracks (1:N)"};

m_trkFilter

ToolHandle<InDet::IInDetTrackSelectionTool> InDet::InDetIterativePriVxFinderTool::m_trkFilter

private

Initial value:

{
    this,
    "TrackSelector",
    "InDet::InDetTrackSelection"
  }

Definition at line 128 of file InDetIterativePriVxFinderTool.h.

                                                       {
    this,
    "TrackSelector",
    "InDet::InDetTrackSelection"
  };

m_useBeamConstraint

BooleanProperty InDet::InDetIterativePriVxFinderTool::m_useBeamConstraint {this, "useBeamConstraint", false}

private

Definition at line 156 of file InDetIterativePriVxFinderTool.h.

{this, "useBeamConstraint", false};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• InDetIterativePriVxFinderTool.h
• InDetIterativePriVxFinderTool.cxx