AxialTrackCreatorSegmentHough Class Reference

Generates axial tracks from segments using the hough algorithm. More...

#include <AxialTrackCreatorSegmentHough.h>

Inheritance diagram for AxialTrackCreatorSegmentHough:

Public Types
using	IOTypes
	Types that should be served to apply on invocation.
using	IOVectors
	Vector types that should be served to apply on invocation.

Public Member Functions
std::string	getDescription () final
	Short description of the findlet.
void	exposeParameters (ModuleParamList *moduleParamList, const std::string &prefix) final
	Expose the parameters to a module.
void	initialize () final
	Initialize the findlet before event processing.
void	apply (const std::vector< CDCSegment2D > &segments, std::vector< CDCTrack > &tracks) final
	Generates the tracks from the given segments into the output argument.
void	terminate () final
	Cleanup the findlet after event processing.
virtual void	apply (ToVector< AIOTypes > &... ioVectors)=0
	Main function executing the algorithm.
void	beginRun () override
	Receive and dispatch signal for the beginning of a new run.
void	beginEvent () override
	Receive and dispatch signal for the start of a new event.
void	endRun () override
	Receive and dispatch signal for the end of the run.

Protected Types
using	ToVector
	Short hand for ToRangeImpl.

Protected Member Functions
void	addProcessingSignalListener (ProcessingSignalListener *psl)
	Register a processing signal listener to be notified.
int	getNProcessingSignalListener ()
	Get the number of currently registered listeners.

Private Types
using	Super = Findlet<const CDCSegment2D, CDCTrack>
	Type of the base class.
using	SimpleSegmentPhi0ImpactCurvHoughTree
	Type of the hough space tree search.

Private Attributes
double	m_param_minNHits = 40
	Parameter: Absolute minimal number of hits to make an axial track.
double	m_param_minFractionNHits = 0.5
	Parameter: Minimal number of hits as a fraction of the total hits in the event.
int	m_param_maxLevel = 12
	Parameter: Level of divisions in the hough space.
std::vector< float >	m_param_curvBounds {{ -0.13, 0.13}}
	Parameter: Curvature bounds of the hough space.
std::vector< float >	m_param_impactBounds {{ -100, 100}}
	Parameter: Impact parameter bounds of the hough space.
int	m_param_discretePhi0Width = 2
	Parameter: Width of the phi0 bins at the lowest level of the hough space.
int	m_param_discretePhi0Overlap = 1
	Parameter: Overlap of the phi0 bins at the lowest level of the hough space.
int	m_param_discreteImpactWidth = 2
	Parameter: Width of the impact bins at the lowest level of the hough space.
int	m_param_discreteImpactOverlap = 1
	Parameter: Overlap of the impact bins at the lowest level of the hough space.
int	m_param_discreteCurvWidth = 2
	Parameter: Width of the curvature bins at the lowest level of the hough space.
int	m_param_discreteCurvOverlap = 1
	Parameter: Overlap of the curvature bins at the lowest level of the hough space.
std::unique_ptr< SimpleSegmentPhi0ImpactCurvHoughTree >	m_houghTree
	The hough space tree search.
std::vector< ProcessingSignalListener * >	m_subordinaryProcessingSignalListeners
	References to subordinary signal processing listener contained in this findlet.
bool	m_initialized = false
	Flag to keep track whether initialization happened before.
bool	m_terminated = false
	Flag to keep track whether termination happened before.
std::string	m_initializedAs
	Name of the type during initialisation.

Static Private Attributes
static const int	c_phi0Divisions = 2
	Fixed parameter: Number of divisions in the phi0 direction.
static const int	c_impactDivisions = 2
	Fixed parameter: Number of divisions in the impact direction.
static const int	c_curvDivisions = 2
	Fixed parameter: Number of divisions in the curv direction.

Detailed Description

Generates axial tracks from segments using the hough algorithm.

Definition at line 30 of file AxialTrackCreatorSegmentHough.h.

Member Typedef Documentation

IOTypes

using IOTypes

inherited

Types that should be served to apply on invocation.

Definition at line 30 of file Findlet.h.

IOVectors

using IOVectors

inherited

Vector types that should be served to apply on invocation.

Definition at line 53 of file Findlet.h.

SimpleSegmentPhi0ImpactCurvHoughTree

using SimpleSegmentPhi0ImpactCurvHoughTree

private

Initial value:

 
        SimpleSegmentHoughTree<InPhi0ImpactCurvBox, c_phi0Divisions, c_impactDivisions, c_curvDivisions>

Type of the hough space tree search.

Definition at line 97 of file AxialTrackCreatorSegmentHough.h.

Super

using Super = Findlet<const CDCSegment2D, CDCTrack>

private

Type of the base class.

Definition at line 34 of file AxialTrackCreatorSegmentHough.h.

ToVector

using ToVector

protectedinherited

Short hand for ToRangeImpl.

Definition at line 49 of file Findlet.h.

Member Function Documentation

addProcessingSignalListener()

void addProcessingSignalListener ( ProcessingSignalListener * psl )

protectedinherited

Register a processing signal listener to be notified.

Definition at line 55 of file CompositeProcessingSignalListener.cc.

{
  m_subordinaryProcessingSignalListeners.push_back(psl);
}

apply()

void apply ( const std::vector< CDCSegment2D > & segments, std::vector< CDCTrack > & tracks )

final

Generates the tracks from the given segments into the output argument.

Setting trajectories

Definition at line 125 of file AxialTrackCreatorSegmentHough.cc.

{
  m_houghTree->fell();
 
  size_t nAxialHits = 0;
  std::vector<const CDCSegment2D*> ptrAxialSegments;
  ptrAxialSegments.reserve(segments.size());
 
  for (const CDCSegment2D& segment : segments) {
    if (segment.getStereoKind() == EStereoKind::c_Axial) {
      ptrAxialSegments.push_back(&segment);
      nAxialHits += segment.size();
    }
  }
 
  m_houghTree->seed(ptrAxialSegments);
  using HoughBox = SimpleSegmentPhi0ImpactCurvHoughTree::HoughBox;
 
  Weight minWeight = std::min(m_param_minNHits, nAxialHits * m_param_minFractionNHits);
 
  using Candidate = std::pair<HoughBox, std::vector<const CDCSegment2D*> >;
  std::vector<Candidate> candidates = m_houghTree->findBest(minWeight);
 
  for (const Candidate& candidate : candidates) {
    const CDCRiemannFitter& fitter = CDCRiemannFitter::getFitter();
    CDCObservations2D observations;
 
    const HoughBox& foundHoughBox = candidate.first;
    const std::vector<const CDCSegment2D*>& foundSegments = candidate.second;
    for (const CDCSegment2D* segment : foundSegments) {
      observations.appendRange(*segment);
    }
    CDCTrajectory2D trajectory2D = fitter.fit(observations);
 
    // Check if the circle has been fitted reverse to the hough box by accident
    {
      double curv = trajectory2D.getCurvature();
      const std::array<DiscreteCurv, 2>& curvs = foundHoughBox.getBounds<DiscreteCurv>();
      float lowerCurv = *(curvs[0]);
      float upperCurv = *(curvs[1]);
      if (static_cast<double>(ESignUtil::common(lowerCurv, upperCurv)) * curv < 0) {
        trajectory2D.reverse();
      }
    }
 
    CDCTrack track;
    for (const CDCSegment2D* segment : foundSegments) {
      for (const CDCRecoHit2D& recoHit2D : *segment) {
        track.push_back(CDCRecoHit3D::reconstruct(recoHit2D, trajectory2D));
      }
    }
    track.sortByArcLength2D();

    if (track.empty()) continue;
    const CDCRecoHit3D& startRecoHit3D = track.front();
    CDCTrajectory3D startTrajectory3D(trajectory2D);
    startTrajectory3D.setLocalOrigin(startRecoHit3D.getRecoPos3D());
    track.setStartTrajectory3D(startTrajectory3D);
 
    const CDCRecoHit3D& endRecoHit3D = track.back();
    CDCTrajectory3D endTrajectory3D(trajectory2D);
    endTrajectory3D.setLocalOrigin(endRecoHit3D.getRecoPos3D());
    track.setEndTrajectory3D(endTrajectory3D);
 
    tracks.push_back(std::move(track));
  }
}

beginEvent()

void beginEvent ( )

overridevirtualinherited

Receive and dispatch signal for the start of a new event.

Reimplemented from ProcessingSignalListener.

Reimplemented in DATCONFPGAFindlet, SpacePointTagger< AResult, ACluster >, SpacePointTagger< Belle2::CKFToPXDResult, Belle2::PXDCluster >, SpacePointTagger< Belle2::CKFToSVDResult, Belle2::SVDCluster >, FindletStoreArrayInput< TWrappedFindlet >, MCSymmetric< BaseAxialSegmentPairFilter >, MCSymmetric< BaseAxialSegmentPairFilter >, MCSymmetric< BaseFacetFilter >, MCSymmetric< BaseFacetFilter >, MCSymmetric< BaseFacetRelationFilter >, MCSymmetric< BaseFacetRelationFilter >, MCSymmetric< BaseSegmentPairFilter >, MCSymmetric< BaseSegmentPairFilter >, MCSymmetric< BaseSegmentPairRelationFilter >, MCSymmetric< BaseSegmentPairRelationFilter >, MCSymmetric< BaseSegmentRelationFilter >, MCSymmetric< BaseSegmentRelationFilter >, MCSymmetric< BaseSegmentTripleFilter >, MCSymmetric< BaseSegmentTripleFilter >, MCSymmetric< BaseSegmentTripleRelationFilter >, MCSymmetric< BaseSegmentTripleRelationFilter >, MCSymmetric< BaseTrackRelationFilter >, MCSymmetric< BaseTrackRelationFilter >, MonopoleStereoHitFinder, MonopoleStereoHitFinderQuadratic, SegmentCreatorMCTruth, SegmentFinderFacetAutomaton, SegmentTrackCombiner, SegmentTrackTruthVarSet, SharingHitsMatcher< ACollectorItem, ACollectionItem >, SharingHitsMatcher< Belle2::TrackFindingCDC::CDCTrack, Belle2::TrackFindingCDC::CDCSegment2D >, StereoHitFinder, StereoHitTruthVarSet, StoreVectorSwapper< IOType, a_alwaysWrite >, StoreVectorSwapper< Belle2::TrackFindingCDC::CDCFacet >, StoreVectorSwapper< Belle2::TrackFindingCDC::CDCSegment2D >, StoreVectorSwapper< Belle2::TrackFindingCDC::CDCSegmentPair >, StoreVectorSwapper< Belle2::TrackFindingCDC::CDCSegmentTriple >, StoreVectorSwapper< Belle2::TrackFindingCDC::CDCTrack >, StoreVectorSwapper< Belle2::TrackFindingCDC::CDCWireHit, true >, TrackFinderAutomaton, TrackFinderSegmentPairAutomaton, TrackFinderSegmentTripleAutomaton, TruthAxialSegmentPairVarSet, TruthSegmentVarSet, TruthTrackVarSet, WireHitMCMultiLoopBlocker, RecoTrackStorer, ROIFinder, and SVDHoughTracking.

Definition at line 31 of file CompositeProcessingSignalListener.cc.

{
  Super::beginEvent();
  for (ProcessingSignalListener* psl : m_subordinaryProcessingSignalListeners) {
    psl->beginEvent();
  }
}

beginRun()

void beginRun ( )

overridevirtualinherited

Receive and dispatch signal for the beginning of a new run.

Reimplemented from ProcessingSignalListener.

Reimplemented in DATCONSVDClusterizer, LayerPXDRelationFilter< AFilter, APrefilter >, LayerPXDRelationFilter< TrackFindingCDC::ChooseableFilter< PXDPairFilterFactory > >, LayerPXDRelationFilter< TrackFindingCDC::ChooseableFilter< PXDPairFilterFactory > >, LayerSVDRelationFilter< AFilter, APrefilter >, LayerSVDRelationFilter< TrackFindingCDC::ChooseableFilter< SVDPairFilterFactory > >, LayerSVDRelationFilter< TrackFindingCDC::ChooseableFilter< SVDPairFilterFactory > >, SectorMapBasedSVDPairFilter, SimplePXDStateFilter, SimpleSVDStateFilter, CutsFromDBWireHitFilter, MVA< Filter< AVarSet::Object > >, MVA< Filter< typename AVarSet::Object > >, MVA< Filter< typename AVarSet::Object > >, WireHitCreator, FourHitFilter, LayerRelationFilter< AFilter >, LayerRelationFilter< TrackFindingCDC::ChooseableFilter< RelationFilterFactory > >, LayerRelationFilter< TrackFindingCDC::ChooseableFilter< RelationFilterFactory > >, QualityIndicatorFilter, RecoTrackStorer, ROIFinder, SpacePointLoaderAndPreparer, ThreeHitFilter, TrackCandidateResultRefiner, TwoHitVirtualIPFilter, and TwoHitVirtualIPQIFilter.

Definition at line 23 of file CompositeProcessingSignalListener.cc.

{
  Super::beginRun();
  for (ProcessingSignalListener* psl : m_subordinaryProcessingSignalListeners) {
    psl->beginRun();
  }
}

endRun()

void endRun ( )

overridevirtualinherited

Receive and dispatch signal for the end of the run.

Reimplemented from ProcessingSignalListener.

Definition at line 39 of file CompositeProcessingSignalListener.cc.

{
  for (ProcessingSignalListener* psl : reversedRange(m_subordinaryProcessingSignalListeners)) {
    psl->endRun();
  }
  Super::endRun();
}

exposeParameters()

void exposeParameters ( ModuleParamList * moduleParamList, const std::string & prefix )

finalvirtual

Expose the parameters to a module.

Reimplemented from CompositeProcessingSignalListener.

Definition at line 30 of file AxialTrackCreatorSegmentHough.cc.

{
  moduleParamList->addParameter(prefixed(prefix, "minNHits"),
                                m_param_minNHits,
                                "Absolute minimal number of hits to make an axial track.",
                                m_param_minNHits);
 
  moduleParamList->addParameter(prefixed(prefix, "minFractionNHits"),
                                m_param_minFractionNHits,
                                "Minimal number of hits as a fraction of the total hits in the event.",
                                m_param_minFractionNHits);
 
  moduleParamList->addParameter(prefixed(prefix, "maxLevel"),
                                m_param_maxLevel,
                                "Level of divisions in the hough space.",
                                m_param_maxLevel);
 
  moduleParamList->addParameter(prefixed(prefix, "curvBounds"),
                                m_param_curvBounds,
                                "Curvature bounds of the hough space.",
                                m_param_curvBounds);
 
  moduleParamList->addParameter(prefixed(prefix, "impactBounds"),
                                m_param_impactBounds,
                                "Impact parameter bounds of the hough space.",
                                m_param_impactBounds);
 
  moduleParamList->addParameter(prefixed(prefix, "discretePhi0Width"),
                                m_param_discretePhi0Width,
                                "Width of the phi0 bins at the lowest level of the hough space.",
                                m_param_discretePhi0Width);
 
  moduleParamList->addParameter(prefixed(prefix, "discretePhi0Overlap"),
                                m_param_discretePhi0Overlap,
                                "Overlap of the phi0 bins at the lowest level of the hough space.",
                                m_param_discretePhi0Overlap);
 
  moduleParamList->addParameter(prefixed(prefix, "discreteImpactWidth"),
                                m_param_discreteImpactWidth,
                                "Width of the impact bins at the lowest level of the hough space.",
                                m_param_discreteImpactWidth);
 
  moduleParamList->addParameter(prefixed(prefix, "discreteImpactOverlap"),
                                m_param_discreteImpactOverlap,
                                "Overlap of the impact bins at the lowest level of the hough space.",
                                m_param_discreteImpactOverlap);
 
  moduleParamList->addParameter(prefixed(prefix, "discreteCurvWidth"),
                                m_param_discreteCurvWidth,
                                "Width of the curvature bins at the lowest level of the hough space.",
                                m_param_discreteCurvWidth);
 
  moduleParamList->addParameter(prefixed(prefix, "discreteCurvOverlap"),
                                m_param_discreteCurvOverlap,
                                "Overlap of the curvature bins at the lowest level of the hough space.",
                                m_param_discreteCurvOverlap);
 
}

getDescription()

std::string getDescription ( )

finalvirtual

Short description of the findlet.

Reimplemented from Findlet< const CDCSegment2D, CDCTrack >.

Definition at line 25 of file AxialTrackCreatorSegmentHough.cc.

{
  return "Generates axial tracks from segments using a hough space over phi0 impact and curvature for the spares case.";
}

getNProcessingSignalListener()

int getNProcessingSignalListener ( )

protectedinherited

Get the number of currently registered listeners.

Definition at line 60 of file CompositeProcessingSignalListener.cc.

{
  return m_subordinaryProcessingSignalListeners.size();
}

initialize()

void initialize ( )

finalvirtual

Initialize the findlet before event processing.

Reimplemented from ProcessingSignalListener.

Definition at line 90 of file AxialTrackCreatorSegmentHough.cc.

{
  Super::initialize();
 
  B2ASSERT("Need exactly two curv bound", m_param_curvBounds.size() == 2);
  B2ASSERT("Need exactly two impact bound", m_param_impactBounds.size() == 2);
 
  const size_t nPhi0Bins = std::pow(c_phi0Divisions, m_param_maxLevel);
  const Phi0BinsSpec phi0BinsSpec(nPhi0Bins,
                                  m_param_discretePhi0Overlap,
                                  m_param_discretePhi0Width);
 
  std::array<double, 2> impactBounds{{m_param_impactBounds.front(), m_param_impactBounds.back()}};
  const size_t nImpactBins = std::pow(c_impactDivisions, m_param_maxLevel);
  const ImpactBinsSpec impactBinsSpec(impactBounds[0],
                                      impactBounds[1],
                                      nImpactBins,
                                      m_param_discreteImpactOverlap,
                                      m_param_discreteImpactWidth);
 
  std::array<double, 2> curvBounds{{m_param_curvBounds.front(), m_param_curvBounds.back()}};
  const size_t nCurvBins = std::pow(c_curvDivisions, m_param_maxLevel);
  const CurvBinsSpec curvBinsSpec(curvBounds[0],
                                  curvBounds[1],
                                  nCurvBins,
                                  m_param_discreteCurvOverlap,
                                  m_param_discreteCurvWidth);
 
  m_houghTree = std::make_unique<SimpleSegmentPhi0ImpactCurvHoughTree>(m_param_maxLevel);
  m_houghTree->assignArray<DiscretePhi0>(phi0BinsSpec.constructArray(), phi0BinsSpec.getNOverlap());
  m_houghTree->assignArray<ContinuousImpact>(impactBounds, impactBinsSpec.getOverlap()); // Continuous
  m_houghTree->assignArray<DiscreteCurv>(curvBinsSpec.constructArray(), curvBinsSpec.getNOverlap());
  m_houghTree->initialize();
}

terminate()

void terminate ( )

finalvirtual

Cleanup the findlet after event processing.

Reimplemented from ProcessingSignalListener.

Definition at line 195 of file AxialTrackCreatorSegmentHough.cc.

{
  m_houghTree->raze();
  m_houghTree.reset();
  Super::terminate();
}

Member Data Documentation

c_curvDivisions

const int c_curvDivisions = 2

staticprivate

Fixed parameter: Number of divisions in the curv direction.

Definition at line 93 of file AxialTrackCreatorSegmentHough.h.

c_impactDivisions

const int c_impactDivisions = 2

staticprivate

Fixed parameter: Number of divisions in the impact direction.

Definition at line 90 of file AxialTrackCreatorSegmentHough.h.

c_phi0Divisions

const int c_phi0Divisions = 2

staticprivate

Fixed parameter: Number of divisions in the phi0 direction.

Definition at line 87 of file AxialTrackCreatorSegmentHough.h.

m_houghTree

std::unique_ptr<SimpleSegmentPhi0ImpactCurvHoughTree> m_houghTree

private

The hough space tree search.

Definition at line 101 of file AxialTrackCreatorSegmentHough.h.

m_initialized

bool m_initialized = false

privateinherited

Flag to keep track whether initialization happened before.

Definition at line 52 of file ProcessingSignalListener.h.

m_initializedAs

std::string m_initializedAs

privateinherited

Name of the type during initialisation.

Definition at line 58 of file ProcessingSignalListener.h.

m_param_curvBounds

std::vector<float> m_param_curvBounds {{ -0.13, 0.13}}

private

Parameter: Curvature bounds of the hough space.

Definition at line 63 of file AxialTrackCreatorSegmentHough.h.

{{ -0.13, 0.13}};

m_param_discreteCurvOverlap

int m_param_discreteCurvOverlap = 1

private

Parameter: Overlap of the curvature bins at the lowest level of the hough space.

Definition at line 84 of file AxialTrackCreatorSegmentHough.h.

m_param_discreteCurvWidth

int m_param_discreteCurvWidth = 2

private

Parameter: Width of the curvature bins at the lowest level of the hough space.

Definition at line 81 of file AxialTrackCreatorSegmentHough.h.

m_param_discreteImpactOverlap

int m_param_discreteImpactOverlap = 1

private

Parameter: Overlap of the impact bins at the lowest level of the hough space.

Definition at line 78 of file AxialTrackCreatorSegmentHough.h.

m_param_discreteImpactWidth

int m_param_discreteImpactWidth = 2

private

Parameter: Width of the impact bins at the lowest level of the hough space.

Definition at line 75 of file AxialTrackCreatorSegmentHough.h.

m_param_discretePhi0Overlap

int m_param_discretePhi0Overlap = 1

private

Parameter: Overlap of the phi0 bins at the lowest level of the hough space.

Definition at line 72 of file AxialTrackCreatorSegmentHough.h.

m_param_discretePhi0Width

int m_param_discretePhi0Width = 2

private

Parameter: Width of the phi0 bins at the lowest level of the hough space.

Definition at line 69 of file AxialTrackCreatorSegmentHough.h.

m_param_impactBounds

std::vector<float> m_param_impactBounds {{ -100, 100}}

private

Parameter: Impact parameter bounds of the hough space.

Definition at line 66 of file AxialTrackCreatorSegmentHough.h.

{{ -100, 100}};

m_param_maxLevel

int m_param_maxLevel = 12

private

Parameter: Level of divisions in the hough space.

Definition at line 60 of file AxialTrackCreatorSegmentHough.h.

m_param_minFractionNHits

double m_param_minFractionNHits = 0.5

private

Parameter: Minimal number of hits as a fraction of the total hits in the event.

Definition at line 57 of file AxialTrackCreatorSegmentHough.h.

m_param_minNHits

double m_param_minNHits = 40

private

Parameter: Absolute minimal number of hits to make an axial track.

Definition at line 54 of file AxialTrackCreatorSegmentHough.h.

m_subordinaryProcessingSignalListeners

std::vector<ProcessingSignalListener*> m_subordinaryProcessingSignalListeners

privateinherited

References to subordinary signal processing listener contained in this findlet.

Definition at line 60 of file CompositeProcessingSignalListener.h.

m_terminated

bool m_terminated = false

privateinherited

Flag to keep track whether termination happened before.

Definition at line 55 of file ProcessingSignalListener.h.

---

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

• tracking/trackFindingCDC/findlets/minimal/include/AxialTrackCreatorSegmentHough.h
• tracking/trackFindingCDC/findlets/minimal/src/AxialTrackCreatorSegmentHough.cc