ActsTrk::HoughVtxFinderTool Class Reference

#include <HoughVtxFinderTool.h>

Inheritance diagram for ActsTrk::HoughVtxFinderTool:

Collaboration diagram for ActsTrk::HoughVtxFinderTool:

Classes
struct	SpacePoint

Public Member Functions
virtual StatusCode	initialize () override
virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * >	findVertex (const EventContext &, const TrackCollection *) const override
virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * >	findVertex (const EventContext &, const xAOD::TrackParticleContainer *) const override
std::pair< std::unique_ptr< xAOD::VertexContainer >, std::unique_ptr< xAOD::VertexAuxContainer > >	findVertex (const EventContext &ctx, const xAOD::SpacePointContainer &spacePointContainer) const

Private Types
using	VertexFinder = Acts::HoughVertexFinder<SpacePoint>

Private Member Functions
const Acts::Logger &	logger () const

Private Attributes
std::unique_ptr< const Acts::Logger >	m_logger {nullptr}
	logging instance
VertexFinder::Config	m_finderCfg
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
UnsignedIntegerProperty	m_minSPs {this, "minSPs", 100, "Minimum amount of spacepoints to attempt vertex finding"}
const bool	m_useBeamSpot = false
UnsignedIntegerProperty	m_targetSPs {this, "targetSPs", 20000, "Ideal amount of spacepoints"}
DoubleProperty	m_minAbsEta {this, "minAbsEta", 0.3, "Minimum range in |eta|"}
DoubleProperty	m_maxAbsEta {this, "maxAbsEta", 4.0, "Maximum range in |eta|"}
UnsignedIntegerProperty	m_minHits {this, "minHits", 4, "Minimum number of hits in Hough plane to consider the cell to contain a track"}
UnsignedIntegerProperty	m_fillNeighbours {this, "fillNeighbours", 0, "Number of neighbouring bins in Hough plane to fill"}
DoubleArrayProperty	m_absEtaRanges {this, "absEtaRanges", {2.0, 4.0}, "Upper threshold for eta ranges"}
DoubleArrayProperty	m_absEtaFractions {this, "absEtaFractions", {0.4, 0.6}, "Amount of spacepoints in such eta ranges"}
DoubleArrayProperty	m_rangeIterZ {this, "rangeIterZ", {200.0, 30.0, 16.0}, "Maximum vertex range to consider"}
UnsignedIntegerArrayProperty	m_nBinsZIterZ {this, "nBinsZIterZ", {800, 180, 80}, "Number of bins in Z direction"}
UnsignedIntegerArrayProperty	m_nBinsCotThetaIterZ {this, "nBinsCotThetaIterZ", {8000, 8000, 8000}, "Number of bins in cot(theta) direction"}
DoubleProperty	m_binsCotThetaDecrease {this, "binsCotThetaDecrease", 1.35, "For every magnitude (in natural log) below targetSPs, the number of bins in cot(theta) will decrease by this factor"}
UnsignedIntegerProperty	m_peakWidth {this, "peakWidth", 3, "Width of the peak when estimating vertex position"}
DoubleArrayProperty	m_defVtxPosition {this, "defVtxPosition", {0.0, 0.0, 0.0}, "Default position of the vertex, might be overwritten by beamspot XY position"}

Detailed Description

Definition at line 28 of file HoughVtxFinderTool.h.

Member Typedef Documentation

VertexFinder

using ActsTrk::HoughVtxFinderTool::VertexFinder = Acts::HoughVertexFinder<SpacePoint>

private

Definition at line 66 of file HoughVtxFinderTool.h.

Member Function Documentation

findVertex() [1/3]

virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > ActsTrk::HoughVtxFinderTool::findVertex ( const EventContext & , const TrackCollection *  ) const

inlineoverridevirtual

Definition at line 36 of file HoughVtxFinderTool.h.

                                                                               {
    ATH_MSG_ERROR("Can't call HoughVtxFinderTool::findVertex(ctx, trackTES)");
    return std::make_pair(nullptr, nullptr);
  }

findVertex() [2/3]

virtual std::pair< xAOD::VertexContainer *, xAOD::VertexAuxContainer * > ActsTrk::HoughVtxFinderTool::findVertex ( const EventContext & , const xAOD::TrackParticleContainer *  ) const

inlineoverridevirtual

Definition at line 41 of file HoughVtxFinderTool.h.

                                                                                          {
    ATH_MSG_ERROR("Can't call HoughVtxFinderTool::findVertex(ctx, trackParticles)");
    return std::make_pair(nullptr, nullptr);
  }

findVertex() [3/3]

std::pair< std::unique_ptr< xAOD::VertexContainer >, std::unique_ptr< xAOD::VertexAuxContainer > > ActsTrk::HoughVtxFinderTool::findVertex	(	const EventContext &	ctx,
		const xAOD::SpacePointContainer &	spacePointContainer ) const

Definition at line 51 of file HoughVtxFinderTool.cxx.

                                                                                                  {
  // vertex finder configuration depending on the beamspot
  auto finderCfgBS = m_finderCfg;
 
  if (m_useBeamSpot) {
    // beamspot XY position for the default XY position of the vertex
    SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{m_beamSpotKey, ctx};
    const Trk::RecVertex &beamposition(beamSpotHandle->beamVtx());
 
    finderCfgBS.defVtxPosition[0] = beamposition.position().x();
    finderCfgBS.defVtxPosition[1] = beamposition.position().y();
    // default Z position is kept the same
 
    ATH_MSG_DEBUG("beamspot position: " << beamposition.position().x() << ", " << beamposition.position().y() << ", "
                                        << beamposition.position().z());
  }
 
  // the output vertex containers
  auto theVertexContainer = std::make_unique<xAOD::VertexContainer>();
  auto theVertexAuxContainer = std::make_unique<xAOD::VertexAuxContainer>();
  theVertexContainer->setStore(theVertexAuxContainer.get());
 
  if (spacePointContainer.size() < m_minSPs) {
    ATH_MSG_DEBUG("Not enough space points for vertex finding; " << spacePointContainer.size() << " < " << m_minSPs);
    // do not attempt vertex finding
    return std::make_pair(std::move(theVertexContainer), std::move(theVertexAuxContainer));
  }
 
  auto vertexFinder = std::make_unique<VertexFinder>(finderCfgBS, logger().cloneWithSuffix("Finder"));
 
  ATH_MSG_DEBUG("default vertex position: " << vertexFinder->config().defVtxPosition[0] << ", "
                                            << vertexFinder->config().defVtxPosition[1] << ", "
                                            << vertexFinder->config().defVtxPosition[2]);
 
  std::vector<SpacePoint> spacePointVector;
  spacePointVector.reserve(spacePointContainer.size());
  for (const auto sp : spacePointContainer) {
    spacePointVector.emplace_back(sp);
  }
 
  ATH_MSG_DEBUG("Number of input space points: " << spacePointVector.size());
  auto vtx = vertexFinder->find(spacePointVector);
 
  if (vtx.ok()) {
    ATH_MSG_DEBUG("Vertex position: " << (*vtx)[0] << ", " << (*vtx)[1] << ", " << (*vtx)[2]);
    auto xAODVertex = theVertexContainer->push_back(std::make_unique<xAOD::Vertex>());
    xAODVertex->setPosition(*vtx);
    xAODVertex->setVertexType(xAOD::VxType::PriVtx);
  } else {
    ATH_MSG_DEBUG("Vertex finding failed");
  }
 
  return std::make_pair(std::move(theVertexContainer), std::move(theVertexAuxContainer));
}

initialize()

StatusCode ActsTrk::HoughVtxFinderTool::initialize ( )

overridevirtual

Definition at line 10 of file HoughVtxFinderTool.cxx.

                                                 {
  ATH_MSG_DEBUG("Initializing ActsTrk::HoughVtxFinderTool");
 
  ATH_CHECK(m_beamSpotKey.initialize(m_useBeamSpot));
 
  // logger
  m_logger = makeActsAthenaLogger(this, "Acts");
 
  // check if vector sizes are compatible
  if (m_absEtaRanges.size() != m_absEtaFractions.size()) {
    ATH_MSG_ERROR("m_absEtaRanges.size() != m_absEtaFractions.size(), " 
                  << m_absEtaRanges.size() << " != " << m_absEtaFractions.size());
    return StatusCode::FAILURE;
  }
  if (m_rangeIterZ.size() != m_nBinsZIterZ.size() || m_rangeIterZ.size() != m_nBinsCotThetaIterZ.size()) {
    ATH_MSG_ERROR("sizes of m_rangeIterZ, m_nBinsZIterZ.size(), and m_nBinsCotThetaIterZ.size() are not equal, "
                  << m_rangeIterZ.size() << ", " << m_nBinsZIterZ.size() << ", " << m_nBinsCotThetaIterZ.size());
    return StatusCode::FAILURE;
  }
 
  // vertex finder configuration
  m_finderCfg.targetSPs = m_targetSPs;
  m_finderCfg.minAbsEta = m_minAbsEta;
  m_finderCfg.maxAbsEta = m_maxAbsEta;
  m_finderCfg.minHits = m_minHits;
  m_finderCfg.fillNeighbours = m_fillNeighbours;
  m_finderCfg.absEtaRanges = m_absEtaRanges;
  m_finderCfg.absEtaFractions = m_absEtaFractions;
  m_finderCfg.rangeIterZ = m_rangeIterZ;
  m_finderCfg.nBinsZIterZ = m_nBinsZIterZ;
  m_finderCfg.nBinsCotThetaIterZ = m_nBinsCotThetaIterZ;
  m_finderCfg.binsCotThetaDecrease = m_binsCotThetaDecrease;
  m_finderCfg.peakWidth = m_peakWidth;
  Acts::Vector3 defVtxPos{m_defVtxPosition[0], m_defVtxPosition[1], m_defVtxPosition[2]};
  m_finderCfg.defVtxPosition = defVtxPos;
 
  ATH_MSG_DEBUG("Successfully initialized ActsTrk::HoughVtxFinderTool");
  return StatusCode::SUCCESS;
}

logger()

const Acts::Logger & ActsTrk::HoughVtxFinderTool::logger ( ) const

inlineprivate

Definition at line 53 of file HoughVtxFinderTool.h.

{ return *m_logger; }

Member Data Documentation

m_absEtaFractions

DoubleArrayProperty ActsTrk::HoughVtxFinderTool::m_absEtaFractions {this, "absEtaFractions", {0.4, 0.6}, "Amount of spacepoints in such eta ranges"}

private

Definition at line 87 of file HoughVtxFinderTool.h.

{this, "absEtaFractions", {0.4, 0.6}, "Amount of spacepoints in such eta ranges"};

m_absEtaRanges

DoubleArrayProperty ActsTrk::HoughVtxFinderTool::m_absEtaRanges {this, "absEtaRanges", {2.0, 4.0}, "Upper threshold for eta ranges"}

private

Definition at line 86 of file HoughVtxFinderTool.h.

{this, "absEtaRanges", {2.0, 4.0}, "Upper threshold for eta ranges"};

m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> ActsTrk::HoughVtxFinderTool::m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}

private

Definition at line 69 of file HoughVtxFinderTool.h.

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

m_binsCotThetaDecrease

DoubleProperty ActsTrk::HoughVtxFinderTool::m_binsCotThetaDecrease {this, "binsCotThetaDecrease", 1.35, "For every magnitude (in natural log) below targetSPs, the number of bins in cot(theta) will decrease by this factor"}

private

Definition at line 92 of file HoughVtxFinderTool.h.

{this, "binsCotThetaDecrease", 1.35, "For every magnitude (in natural log) below targetSPs, the number of bins in cot(theta) will decrease by this factor"};

m_defVtxPosition

DoubleArrayProperty ActsTrk::HoughVtxFinderTool::m_defVtxPosition {this, "defVtxPosition", {0.0, 0.0, 0.0}, "Default position of the vertex, might be overwritten by beamspot XY position"}

private

Definition at line 94 of file HoughVtxFinderTool.h.

{this, "defVtxPosition", {0.0, 0.0, 0.0}, "Default position of the vertex, might be overwritten by beamspot XY position"};

m_fillNeighbours

UnsignedIntegerProperty ActsTrk::HoughVtxFinderTool::m_fillNeighbours {this, "fillNeighbours", 0, "Number of neighbouring bins in Hough plane to fill"}

private

Definition at line 84 of file HoughVtxFinderTool.h.

{this, "fillNeighbours", 0, "Number of neighbouring bins in Hough plane to fill"};

m_finderCfg

VertexFinder::Config ActsTrk::HoughVtxFinderTool::m_finderCfg

private

Definition at line 67 of file HoughVtxFinderTool.h.

m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::HoughVtxFinderTool::m_logger {nullptr}

private

logging instance

Definition at line 52 of file HoughVtxFinderTool.h.

{nullptr};

m_maxAbsEta

DoubleProperty ActsTrk::HoughVtxFinderTool::m_maxAbsEta {this, "maxAbsEta", 4.0, "Maximum range in |eta|"}

private

Definition at line 82 of file HoughVtxFinderTool.h.

{this, "maxAbsEta", 4.0, "Maximum range in |eta|"};

m_minAbsEta

DoubleProperty ActsTrk::HoughVtxFinderTool::m_minAbsEta {this, "minAbsEta", 0.3, "Minimum range in |eta|"}

private

Definition at line 81 of file HoughVtxFinderTool.h.

{this, "minAbsEta", 0.3, "Minimum range in |eta|"};

m_minHits

UnsignedIntegerProperty ActsTrk::HoughVtxFinderTool::m_minHits {this, "minHits", 4, "Minimum number of hits in Hough plane to consider the cell to contain a track"}

private

Definition at line 83 of file HoughVtxFinderTool.h.

{this, "minHits", 4, "Minimum number of hits in Hough plane to consider the cell to contain a track"};

m_minSPs

UnsignedIntegerProperty ActsTrk::HoughVtxFinderTool::m_minSPs {this, "minSPs", 100, "Minimum amount of spacepoints to attempt vertex finding"}

private

Definition at line 71 of file HoughVtxFinderTool.h.

{this, "minSPs", 100, "Minimum amount of spacepoints to attempt vertex finding"};

m_nBinsCotThetaIterZ

UnsignedIntegerArrayProperty ActsTrk::HoughVtxFinderTool::m_nBinsCotThetaIterZ {this, "nBinsCotThetaIterZ", {8000, 8000, 8000}, "Number of bins in cot(theta) direction"}

private

Definition at line 91 of file HoughVtxFinderTool.h.

{this, "nBinsCotThetaIterZ", {8000, 8000, 8000}, "Number of bins in cot(theta) direction"};

m_nBinsZIterZ

UnsignedIntegerArrayProperty ActsTrk::HoughVtxFinderTool::m_nBinsZIterZ {this, "nBinsZIterZ", {800, 180, 80}, "Number of bins in Z direction"}

private

Definition at line 90 of file HoughVtxFinderTool.h.

{this, "nBinsZIterZ", {800, 180, 80}, "Number of bins in Z direction"};

m_peakWidth

UnsignedIntegerProperty ActsTrk::HoughVtxFinderTool::m_peakWidth {this, "peakWidth", 3, "Width of the peak when estimating vertex position"}

private

Definition at line 93 of file HoughVtxFinderTool.h.

{this, "peakWidth", 3, "Width of the peak when estimating vertex position"};

m_rangeIterZ

DoubleArrayProperty ActsTrk::HoughVtxFinderTool::m_rangeIterZ {this, "rangeIterZ", {200.0, 30.0, 16.0}, "Maximum vertex range to consider"}

private

Definition at line 89 of file HoughVtxFinderTool.h.

{this, "rangeIterZ", {200.0, 30.0, 16.0}, "Maximum vertex range to consider"};

m_targetSPs

UnsignedIntegerProperty ActsTrk::HoughVtxFinderTool::m_targetSPs {this, "targetSPs", 20000, "Ideal amount of spacepoints"}

private

Definition at line 80 of file HoughVtxFinderTool.h.

{this, "targetSPs", 20000, "Ideal amount of spacepoints"};

m_useBeamSpot

const bool ActsTrk::HoughVtxFinderTool::m_useBeamSpot = false

private

Definition at line 74 of file HoughVtxFinderTool.h.

---

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

• HoughVtxFinderTool.h
• HoughVtxFinderTool.cxx