AxialTrackCreatorSegmentHough Class Reference

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

#include <AxialTrackCreatorSegmentHough.h>

Inheritance diagram for AxialTrackCreatorSegmentHough:

Collaboration diagram for AxialTrackCreatorSegmentHough:

Public Types
using	IOTypes = std::tuple< AIOTypes... >
	Types that should be served to apply on invokation.
using	IOVectors = std::tuple< std::vector< AIOTypes >... >
	Vector types that should be served to apply on invokation.

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. More...
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 = typename ToVectorImpl< T >::Type
	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 = SimpleSegmentHoughTree< InPhi0ImpactCurvBox, c_phi0Divisions, c_impactDivisions, c_curvDivisions >
	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 happend before.
bool	m_terminated = false
	Flag to keep track whether termination happend 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 Function Documentation

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

---

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