ActsTrk::detail::DuplicateSeedDetector Class Reference

#include <DuplicateSeedDetector.h>

Collaboration diagram for ActsTrk::detail::DuplicateSeedDetector:

Public Member Functions
	DuplicateSeedDetector (std::size_t numSeeds, bool enabled)
	DuplicateSeedDetector (const DuplicateSeedDetector &)=delete
DuplicateSeedDetector &	operator= (const DuplicateSeedDetector &)=delete
	DuplicateSeedDetector (DuplicateSeedDetector &&) noexcept=default
DuplicateSeedDetector &	operator= (DuplicateSeedDetector &&) noexcept=default
	~DuplicateSeedDetector ()=default
void	addSeeds (std::size_t typeIndex, const ActsTrk::SeedContainer &seeds)
void	newTrajectory ()
void	addMeasurement (const ActsTrk::ATLASUncalibSourceLink &sl)
bool	isDuplicate (std::size_t typeIndex, std::size_t iseed)
bool	isEnabled () const
const std::unordered_multimap< const xAOD::UncalibratedMeasurement *, std::size_t > &	seedIndexes () const
const std::vector< std::size_t > &	nUsedMeasurements () const
const std::vector< std::size_t > &	nSeedMeasurements () const
const std::vector< bool > &	isDuplicateSeeds () const
const std::vector< std::size_t > &	seedOffsets () const
std::size_t	numSeeds () const
std::size_t	nextSeeds () const
std::size_t	foundSeeds () const

Private Attributes
bool	m_disabled {false}
std::unordered_multimap< const xAOD::UncalibratedMeasurement *, std::size_t >	m_seedIndexes {}
std::vector< std::size_t >	m_nUsedMeasurements {}
std::vector< std::size_t >	m_nSeedMeasurements {}
std::vector< bool >	m_isDuplicateSeeds {}
std::vector< std::size_t >	m_seedOffsets {}
std::size_t	m_numSeeds {0ul}
std::size_t	m_nextSeeds {0ul}
std::size_t	m_foundSeeds {0ul}

Detailed Description

Definition at line 19 of file DuplicateSeedDetector.h.

Constructor & Destructor Documentation

DuplicateSeedDetector() [1/3]

ActsTrk::detail::DuplicateSeedDetector::DuplicateSeedDetector	(	std::size_t	numSeeds,
		bool	enabled
	)

Definition at line 9 of file DuplicateSeedDetector.cxx.

    : m_disabled(!enabled),
      m_nUsedMeasurements(enabled ? numSeeds : 0u, 0u),
      m_nSeedMeasurements(enabled ? numSeeds : 0u, 0u),
      m_isDuplicateSeeds(enabled ? numSeeds : 0u, false)
  {
    if (m_disabled)
      return;
    m_seedIndexes.reserve(6 * numSeeds); // 6 hits/seed for strips (3 for pixels)
    m_seedOffsets.reserve(2);
  }

DuplicateSeedDetector() [2/3]

ActsTrk::detail::DuplicateSeedDetector::DuplicateSeedDetector ( const DuplicateSeedDetector &  )

delete

DuplicateSeedDetector() [3/3]

ActsTrk::detail::DuplicateSeedDetector::DuplicateSeedDetector ( DuplicateSeedDetector &&  )

defaultnoexcept

~DuplicateSeedDetector()

ActsTrk::detail::DuplicateSeedDetector::~DuplicateSeedDetector ( )

default

Member Function Documentation

addMeasurement()

void ActsTrk::detail::DuplicateSeedDetector::addMeasurement

(

const ActsTrk::ATLASUncalibSourceLink &

sl

)

Definition at line 56 of file DuplicateSeedDetector.cxx.

                                                                                    {
    if (m_disabled or m_nextSeeds == m_nUsedMeasurements.size()) return;
 
    for (auto [iiseed, eiseed] = m_seedIndexes.equal_range(&(ActsTrk::getUncalibratedMeasurement(sl)));
     iiseed != eiseed; ++iiseed) {
    std::size_t iseed = iiseed->second;
        assert(iseed < m_nUsedMeasurements.size());
    
        if (iseed < m_nextSeeds or m_isDuplicateSeeds[iseed]) continue;
 
        if (++m_nUsedMeasurements[iseed] >= m_nSeedMeasurements[iseed]) {
      assert(m_nUsedMeasurements[iseed] == m_nSeedMeasurements[iseed]); // shouldn't ever find more
      m_isDuplicateSeeds[iseed] = true;
    }
        ++m_foundSeeds;
    }
  }

addSeeds()

void ActsTrk::detail::DuplicateSeedDetector::addSeeds	(	std::size_t	typeIndex,
		const ActsTrk::SeedContainer &	seeds
	)

Definition at line 22 of file DuplicateSeedDetector.cxx.

  {
    if (m_disabled) return;
    if (!(typeIndex < m_seedOffsets.size()))
      m_seedOffsets.resize(typeIndex + 1);
    m_seedOffsets[typeIndex] = m_numSeeds;
    
    for (const ActsTrk::Seed *seed : seeds) {
      if (!seed) continue;
 
      for (const xAOD::SpacePoint *sp : seed->sp()) {
    const std::vector< const xAOD::UncalibratedMeasurement* > &els = sp->measurements();
    for (const xAOD::UncalibratedMeasurement *meas : els) {
      m_seedIndexes.insert({meas, m_numSeeds});
      ++m_nSeedMeasurements[m_numSeeds];
    }
      }
      ++m_numSeeds;
    }
  }

foundSeeds()

std::size_t ActsTrk::detail::DuplicateSeedDetector::foundSeeds ( ) const

inline

isDuplicate()

bool ActsTrk::detail::DuplicateSeedDetector::isDuplicate	(	std::size_t	typeIndex,
		std::size_t	iseed
	)

Definition at line 75 of file DuplicateSeedDetector.cxx.

                                       {
    if (m_disabled) return false;
 
    if (typeIndex < m_seedOffsets.size()) {
      iseed += m_seedOffsets[typeIndex];
    }
    
    assert(iseed < m_isDuplicateSeeds.size());
    // If iseed not increasing, we will miss some duplicate seeds, but won't exclude needed seeds.
    if (iseed >= m_nextSeeds) {
      m_nextSeeds = iseed + 1;
    }
    
    return m_isDuplicateSeeds[iseed];
  }

isDuplicateSeeds()

const std::vector<bool>& ActsTrk::detail::DuplicateSeedDetector::isDuplicateSeeds ( ) const

inline

isEnabled()

bool ActsTrk::detail::DuplicateSeedDetector::isEnabled ( ) const

inline

newTrajectory()

void ActsTrk::detail::DuplicateSeedDetector::newTrajectory

(

)

Definition at line 44 of file DuplicateSeedDetector.cxx.

                                            {
    if (m_disabled or m_foundSeeds == 0 or m_nextSeeds == m_nUsedMeasurements.size())
      return;
    
    auto beg = m_nUsedMeasurements.begin();
    if (m_nextSeeds < m_nUsedMeasurements.size()) {
      std::advance(beg, m_nextSeeds);
    }
    
    std::fill(beg, m_nUsedMeasurements.end(), 0ul);
  }

nextSeeds()

std::size_t ActsTrk::detail::DuplicateSeedDetector::nextSeeds ( ) const

inline

nSeedMeasurements()

const std::vector<std::size_t>& ActsTrk::detail::DuplicateSeedDetector::nSeedMeasurements ( ) const

inline

numSeeds()

std::size_t ActsTrk::detail::DuplicateSeedDetector::numSeeds ( ) const

inline

nUsedMeasurements()

const std::vector<std::size_t>& ActsTrk::detail::DuplicateSeedDetector::nUsedMeasurements ( ) const

inline

operator=() [1/2]

DuplicateSeedDetector& ActsTrk::detail::DuplicateSeedDetector::operator= ( const DuplicateSeedDetector &  )

delete

operator=() [2/2]

DuplicateSeedDetector& ActsTrk::detail::DuplicateSeedDetector::operator= ( DuplicateSeedDetector &&  )

defaultnoexcept

seedIndexes()

const std::unordered_multimap<const xAOD::UncalibratedMeasurement *, std::size_t>& ActsTrk::detail::DuplicateSeedDetector::seedIndexes ( ) const

inline

seedOffsets()

const std::vector<std::size_t>& ActsTrk::detail::DuplicateSeedDetector::seedOffsets ( ) const

inline

Member Data Documentation

m_disabled

bool ActsTrk::detail::DuplicateSeedDetector::m_disabled {false}

private

Definition at line 49 of file DuplicateSeedDetector.h.

m_foundSeeds

std::size_t ActsTrk::detail::DuplicateSeedDetector::m_foundSeeds {0ul}

private

Definition at line 57 of file DuplicateSeedDetector.h.

m_isDuplicateSeeds

std::vector<bool> ActsTrk::detail::DuplicateSeedDetector::m_isDuplicateSeeds {}

private

Definition at line 53 of file DuplicateSeedDetector.h.

m_nextSeeds

std::size_t ActsTrk::detail::DuplicateSeedDetector::m_nextSeeds {0ul}

private

Definition at line 56 of file DuplicateSeedDetector.h.

m_nSeedMeasurements

std::vector<std::size_t> ActsTrk::detail::DuplicateSeedDetector::m_nSeedMeasurements {}

private

Definition at line 52 of file DuplicateSeedDetector.h.

m_numSeeds

std::size_t ActsTrk::detail::DuplicateSeedDetector::m_numSeeds {0ul}

private

Definition at line 55 of file DuplicateSeedDetector.h.

m_nUsedMeasurements

std::vector<std::size_t> ActsTrk::detail::DuplicateSeedDetector::m_nUsedMeasurements {}

private

Definition at line 51 of file DuplicateSeedDetector.h.

m_seedIndexes

std::unordered_multimap<const xAOD::UncalibratedMeasurement *, std::size_t> ActsTrk::detail::DuplicateSeedDetector::m_seedIndexes {}

private

Definition at line 50 of file DuplicateSeedDetector.h.

m_seedOffsets

std::vector<std::size_t> ActsTrk::detail::DuplicateSeedDetector::m_seedOffsets {}

private

Definition at line 54 of file DuplicateSeedDetector.h.

---

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

• DuplicateSeedDetector.h
• DuplicateSeedDetector.cxx