AxialTrackUtil Struct Reference

Utility structure gathering heuristic functions used during the axial track finding. More...

#include <AxialTrackUtil.h>

Static Public Member Functions
static void	addCandidateFromHits (const std::vector< const TrackingUtilities::CDCWireHit * > &foundAxialWireHits, const std::vector< const TrackingUtilities::CDCWireHit * > &allAxialWireHits, std::vector< TrackingUtilities::CDCTrack > &axialTracks, bool withPostprocessing=true)
	Create CDCTrack using CDCWireHit hits and store it in the list. Then call the postprocessing on it.
static bool	postprocessTrack (TrackingUtilities::CDCTrack &track, const std::vector< const TrackingUtilities::CDCWireHit * > &allAxialWireHits)
	Perform all track postprocessing - return whether the track is considered good after the postprocessing.
static void	normalizeTrack (TrackingUtilities::CDCTrack &track)
	Refit and resort the track. Unmask all hits.
static void	updateRecoHit3D (const TrackingUtilities::CDCTrajectory2D &trajectory2D, TrackingUtilities::CDCRecoHit3D &hit)
	update given CDCRecoHit3D with given trajectory
static void	deleteHitsFarAwayFromTrajectory (TrackingUtilities::CDCTrack &track, double maximumDistance=0.2)
	Postprocessing: Delete axial hits that do not "match" to the given track.
static void	assignNewHitsToTrack (TrackingUtilities::CDCTrack &track, const std::vector< const TrackingUtilities::CDCWireHit * > &allAxialWireHits, double minimalDistance=0.2)
	Assign new hits to the track basing on the distance from the hit to the track.
static std::vector< TrackingUtilities::CDCRecoHit3D >	splitBack2BackTrack (TrackingUtilities::CDCTrack &track)
	Tries to split back-to-back tracks into two different tracks.
static bool	isBack2BackTrack (TrackingUtilities::CDCTrack &track)
	Checks whether the track has hits on both arms as seen from the origin.
static TrackingUtilities::ESign	getMajorArmSign (const TrackingUtilities::CDCTrack &track, const TrackingUtilities::Vector2D &center)
	Calculate whether the majority of hits is to the right or to the left relative to the line from origin to given center.
static int	getArmSignVote (const TrackingUtilities::CDCTrack &track, const TrackingUtilities::Vector2D &center)
	Calculate the sum of right and left votes for the hits relative to the center.
static void	removeHitsAfterSuperLayerBreak (TrackingUtilities::CDCTrack &track)
	Searches for a break in the super layer chain and remove all hits that come after that.
static TrackingUtilities::ESign	getArmSign (const TrackingUtilities::CDCRecoHit3D &hit, const TrackingUtilities::Vector2D &center)
	Calculate whether the hits is to the right or to the left relative to the line from origin to the given center.
static void	deleteTracksWithLowFitProbability (std::vector< TrackingUtilities::CDCTrack > &axialTracks, double minimal_probability_for_good_fit=0.4)
	Check an (improper) p-values of the tracks. If they are below the given value, delete the track from the list.
static void	deleteShortTracks (std::vector< TrackingUtilities::CDCTrack > &axialTracks, double minimal_size=5)
	Remove tracks that are shorter than the given number of hits.

Static Private Member Functions
static bool	checkTrackQuality (const TrackingUtilities::CDCTrack &track)
	Check track quality – currently based on number of hits only.
static std::vector< CDC::ISuperLayer >	getSLayerHoles (const std::array< int, CDC::ISuperLayerUtil::c_N > &nHitsBySLayer)
	Helper function getting the empty axial!
static CDC::ISuperLayer	getFirstOccupiedISuperLayer (const std::array< int, CDC::ISuperLayerUtil::c_N > &nHitsBySLayer)
	Helper function to extract the first filled entry in the array of super layers ( = the start superlayer of the track).
static CDC::ISuperLayer	getLastOccupiedISuperLayer (const std::array< int, CDC::ISuperLayerUtil::c_N > &nHitsBySLayer)
	Helper function to extract the last filled entry in the array of super layers ( = the final superlayer of the track).

Detailed Description

Utility structure gathering heuristic functions used during the axial track finding.

Definition at line 34 of file AxialTrackUtil.h.

Member Function Documentation

addCandidateFromHits()

void addCandidateFromHits ( const std::vector< const TrackingUtilities::CDCWireHit * > & foundAxialWireHits, const std::vector< const TrackingUtilities::CDCWireHit * > & allAxialWireHits, std::vector< TrackingUtilities::CDCTrack > & axialTracks, bool withPostprocessing = true )

static

Create CDCTrack using CDCWireHit hits and store it in the list. Then call the postprocessing on it.

Mark hits as taken and add the new track to the track list

Masked bad hits

Definition at line 26 of file AxialTrackUtil.cc.

{
  if (foundAxialWireHits.empty()) return;
 
  // New track
  CDCTrack track;
 
  // Fit trajectory
  const CDCRiemannFitter& fitter = CDCRiemannFitter::getFitter();
  CDCTrajectory2D trajectory2D = fitter.fit(foundAxialWireHits);
  track.setStartTrajectory3D(CDCTrajectory3D(trajectory2D, CDCTrajectorySZ::basicAssumption()));
 
  // Reconstruct and add hits
  for (const CDCWireHit* wireHit : foundAxialWireHits) {
    AutomatonCell& automatonCell = wireHit->getAutomatonCell();
    if (automatonCell.hasTakenFlag()) continue;
    CDCRecoHit3D recoHit3D = CDCRecoHit3D::reconstructNearest(wireHit, trajectory2D);
    track.push_back(std::move(recoHit3D));
 
    automatonCell.setTakenFlag(true);
  }
  track.sortByArcLength2D();
 
  // Change everything again in the postprocessing, if desired
  bool success = withPostprocessing ? postprocessTrack(track, allAxialWireHits) : true;
  if (success) {
    for (const CDCRecoHit3D& recoHit3D : track) {
      recoHit3D.getWireHit().getAutomatonCell().setTakenFlag(true);
    }
    axialTracks.emplace_back(std::move(track));
  } else {
    for (const CDCRecoHit3D& recoHit3D : track) {
      recoHit3D.getWireHit().getAutomatonCell().setMaskedFlag(true);
      recoHit3D.getWireHit().getAutomatonCell().setTakenFlag(false);
    }
  }
}

assignNewHitsToTrack()

void assignNewHitsToTrack ( TrackingUtilities::CDCTrack & track, const std::vector< const TrackingUtilities::CDCWireHit * > & allAxialWireHits, double minimalDistance = 0.2 )

static

Assign new hits to the track basing on the distance from the hit to the track.

Definition at line 177 of file AxialTrackUtil.cc.

{
  if (track.size() < 10) return;
 
  const CDCTrajectory2D& trackTrajectory2D = track.getStartTrajectory3D().getTrajectory2D();
 
  for (const CDCWireHit* wireHit : allAxialWireHits) {
    if (wireHit->getAutomatonCell().hasTakenFlag()) continue;
 
    CDCRecoHit3D recoHit3D = CDCRecoHit3D::reconstructNearest(wireHit, trackTrajectory2D);
    const Vector2D& recoPos2D = recoHit3D.getRecoPos2D();
 
    if (fabs(trackTrajectory2D.getDist2D(recoPos2D)) < minimalDistance) {
      track.push_back(std::move(recoHit3D));
      recoHit3D.getWireHit().getAutomatonCell().setTakenFlag();
    }
  }
}

checkTrackQuality()

bool checkTrackQuality ( const TrackingUtilities::CDCTrack & track )

staticprivate

Check track quality – currently based on number of hits only.

Definition at line 90 of file AxialTrackUtil.cc.

{
  return not(track.size() < 5);
}

deleteHitsFarAwayFromTrajectory()

void deleteHitsFarAwayFromTrajectory ( TrackingUtilities::CDCTrack & track, double maximumDistance = 0.2 )

static

Postprocessing: Delete axial hits that do not "match" to the given track.

This is done by checking the distance between the hits and the trajectory, which should not exceed the maximum_distance parameter.

As this function used the masked flag, all hits should have their masked flag set to false before calling this function.

Definition at line 142 of file AxialTrackUtil.cc.

{
  const CDCTrajectory2D& trajectory2D = track.getStartTrajectory3D().getTrajectory2D();
  auto farFromTrajectory = [&trajectory2D, &maximumDistance](CDCRecoHit3D & recoHit3D) {
    Vector2D refPos2D = recoHit3D.getRefPos2D();
    double distance = trajectory2D.getDist2D(refPos2D) - recoHit3D.getSignedRecoDriftLength();
    if (std::fabs(distance) > maximumDistance) {
      recoHit3D.getWireHit().getAutomatonCell().setTakenFlag(false);
      // This must be here as the deleted hits must not participate in the hough search again.
      recoHit3D.getWireHit().getAutomatonCell().setMaskedFlag(true);
      return true;
    }
    return false;
  };
  erase_remove_if(track, farFromTrajectory);
}

deleteShortTracks()

void deleteShortTracks ( std::vector< TrackingUtilities::CDCTrack > & axialTracks, double minimal_size = 5 )

static

Remove tracks that are shorter than the given number of hits.

Definition at line 198 of file AxialTrackUtil.cc.

{
  const auto isShort = [&](const CDCTrack & track) {
    if (track.size() < minimal_size) {
      // Release hits
      track.forwardTakenFlag(false);
      return true;
    }
    return false;
  };
  erase_remove_if(axialTracks, isShort);
}

deleteTracksWithLowFitProbability()

void deleteTracksWithLowFitProbability ( std::vector< TrackingUtilities::CDCTrack > & axialTracks, double minimal_probability_for_good_fit = 0.4 )

static

Check an (improper) p-values of the tracks. If they are below the given value, delete the track from the list.

Definition at line 159 of file AxialTrackUtil.cc.

{
  const CDCKarimakiFitter& trackFitter = CDCKarimakiFitter::getNoDriftVarianceFitter();
  const auto lowPValue = [&](const CDCTrack & track) {
    CDCTrajectory2D fittedTrajectory = trackFitter.fit(track);
    // Keep good fits - p-value is not really a probability,
    // but what can you do if the original author did not mind...
    if (not(fittedTrajectory.getPValue() >= minimal_probability_for_good_fit)) {
      // Release hits
      track.forwardTakenFlag(false);
      return true;
    }
    return false;
  };
  erase_remove_if(axialTracks, lowPValue);
}

getArmSign()

ESign getArmSign ( const TrackingUtilities::CDCRecoHit3D & hit, const TrackingUtilities::Vector2D & center )

static

Calculate whether the hits is to the right or to the left relative to the line from origin to the given center.

Return values

ESign::c_Right	hit is on the right
ESign::c_Left	hit is on the left
ESign::c_Zero	rare boarderline case
ESign::c_Invalid	given hit has a nan value

Definition at line 283 of file AxialTrackUtil.cc.

{
  return sign(center.isRightOrLeftOf(hit.getRecoPos2D()));
}

getArmSignVote()

int getArmSignVote ( const TrackingUtilities::CDCTrack & track, const TrackingUtilities::Vector2D & center )

static

Calculate the sum of right and left votes for the hits relative to the center.

Positive indicates a majority of right by that amount. Negative indicates a left majority.

Definition at line 258 of file AxialTrackUtil.cc.

{
  int votePos = 0;
  int voteNeg = 0;
 
  if (center.hasNAN()) {
    B2WARNING("Trajectory is not set or wrong!");
    return 0;
  }
 
  for (const CDCRecoHit3D& hit : track) {
    ESign armSign = getArmSign(hit, center);
 
    if (armSign == ESign::c_Plus) {
      ++votePos;
    } else if (armSign == ESign::c_Minus) {
      ++voteNeg;
    } else {
      B2ERROR("Strange behaviour of getArmSignVote");
    }
  }
  int armSignVote = votePos - voteNeg;
  return armSignVote;
}

getFirstOccupiedISuperLayer()

ISuperLayer getFirstOccupiedISuperLayer ( const std::array< int, CDC::ISuperLayerUtil::c_N > & nHitsBySLayer )

staticprivate

Helper function to extract the first filled entry in the array of super layers ( = the start superlayer of the track).

Definition at line 359 of file AxialTrackUtil.cc.

{
  for (ISuperLayer iSLayer = 0; iSLayer < ISuperLayerUtil::c_N; ++iSLayer) {
    if (nHitsBySLayer[iSLayer] > 0) return iSLayer;
  }
  return ISuperLayerUtil::c_Invalid;
}

getLastOccupiedISuperLayer()

ISuperLayer getLastOccupiedISuperLayer ( const std::array< int, CDC::ISuperLayerUtil::c_N > & nHitsBySLayer )

staticprivate

Helper function to extract the last filled entry in the array of super layers ( = the final superlayer of the track).

Definition at line 367 of file AxialTrackUtil.cc.

{
  for (ISuperLayer iSLayer = ISuperLayerUtil::c_N - 1; iSLayer >= 0; --iSLayer) {
    if (nHitsBySLayer[iSLayer] > 0) return iSLayer;
  }
  return ISuperLayerUtil::c_Invalid;
}

getMajorArmSign()

ESign getMajorArmSign ( const TrackingUtilities::CDCTrack & track, const TrackingUtilities::Vector2D & center )

static

Calculate whether the majority of hits is to the right or to the left relative to the line from origin to given center.

Return values

ESign::c_Right	most hits are on the right
ESign::c_Left	most hits are on the left
ESign::c_Zero	no majority
ESign::c_Invalid	given center has a nan value

Definition at line 248 of file AxialTrackUtil.cc.

{
  int armSignVote = getArmSignVote(track, center);
  if (armSignVote > 0) {
    return ESign::c_Plus;
  } else {
    return ESign::c_Minus;
  }
}

getSLayerHoles()

std::vector< ISuperLayer > getSLayerHoles ( const std::array< int, CDC::ISuperLayerUtil::c_N > & nHitsBySLayer )

staticprivate

Helper function getting the empty axial!

super layers that appear in the chain of super layers that is supposed to be occupied

Definition at line 339 of file AxialTrackUtil.cc.

{
  std::vector<ISuperLayer> sLayerHoles;
 
  // Find the start end end point.
  ISuperLayer firstSlayer = getFirstOccupiedISuperLayer(nHitsBySLayer);
  ISuperLayer lastSlayer = getLastOccupiedISuperLayer(nHitsBySLayer);
 
  if (ISuperLayerUtil::isInvalid(firstSlayer) or ISuperLayerUtil::isInvalid(lastSlayer)) {
    return sLayerHoles;
  }
 
  for (ISuperLayer iSLayer = firstSlayer; iSLayer <= lastSlayer; iSLayer += 2) {
    if (nHitsBySLayer[iSLayer] == 0) {
      sLayerHoles.push_back(iSLayer);
    }
  }
  return sLayerHoles;
}

isBack2BackTrack()

bool isBack2BackTrack ( TrackingUtilities::CDCTrack & track )

static

Checks whether the track has hits on both arms as seen from the origin.

Definition at line 238 of file AxialTrackUtil.cc.

{
  Vector2D center = track.getStartTrajectory3D().getGlobalCenter();
  int armSignVote = getArmSignVote(track, center);
  if (std::abs(armSignVote) < int(track.size()) and std::fabs(center.cylindricalR()) > 60.) {
    return true;
  }
  return false;
}

normalizeTrack()

void normalizeTrack ( TrackingUtilities::CDCTrack & track )

static

Refit and resort the track. Unmask all hits.

Definition at line 95 of file AxialTrackUtil.cc.

{
  // Set the start point of the trajectory to the first hit
  if (track.size() < 5) return;
 
  CDCObservations2D observations2D(EFitPos::c_RecoPos);
  for (const CDCRecoHit3D& item : track) {
    observations2D.append(item);
  }
 
  const CDCRiemannFitter& fitter = CDCRiemannFitter::getFitter();
  CDCTrajectory2D trackTrajectory2D = fitter.fit(observations2D);
  Vector2D center = trackTrajectory2D.getGlobalCenter();
 
  // Arm used as a proxy for the charge of the track
  // Correct if the track originates close to the origin
  ESign expectedCharge = AxialTrackUtil::getMajorArmSign(track, center);
 
  if (trackTrajectory2D.getChargeSign() != expectedCharge) trackTrajectory2D.reverse();
 
  trackTrajectory2D.setLocalOrigin(trackTrajectory2D.getGlobalPerigee());
  for (CDCRecoHit3D& recoHit : track) {
    AxialTrackUtil::updateRecoHit3D(trackTrajectory2D, recoHit);
  }
 
  track.sortByArcLength2D();
 
  CDCTrajectory3D trajectory3D(trackTrajectory2D, CDCTrajectorySZ::basicAssumption());
  track.setStartTrajectory3D(trajectory3D);
 
  Vector3D backPosition = track.back().getRecoPos3D();
  trajectory3D.setLocalOrigin(backPosition);
  track.setEndTrajectory3D(trajectory3D);
}

postprocessTrack()

bool postprocessTrack ( TrackingUtilities::CDCTrack & track, const std::vector< const TrackingUtilities::CDCWireHit * > & allAxialWireHits )

static

Perform all track postprocessing - return whether the track is considered good after the postprocessing.

Definition at line 69 of file AxialTrackUtil.cc.

{
  AxialTrackUtil::normalizeTrack(track);
 
  AxialTrackUtil::deleteHitsFarAwayFromTrajectory(track);
  AxialTrackUtil::normalizeTrack(track);
  if (not checkTrackQuality(track)) {
    return false;
  }
 
  AxialTrackUtil::assignNewHitsToTrack(track, allAxialWireHits);
  AxialTrackUtil::normalizeTrack(track);
 
  AxialTrackUtil::splitBack2BackTrack(track);
  AxialTrackUtil::normalizeTrack(track);
  if (not checkTrackQuality(track)) {
    return false;
  }
  return true;
}

removeHitsAfterSuperLayerBreak()

void removeHitsAfterSuperLayerBreak ( TrackingUtilities::CDCTrack & track )

static

Searches for a break in the super layer chain and remove all hits that come after that.

Definition at line 288 of file AxialTrackUtil.cc.

{
  double apogeeArcLength = fabs(track.getStartTrajectory3D().getGlobalCircle().perimeter()) / 2.;
 
  std::array<int, ISuperLayerUtil::c_N> nForwardArmHitsBySLayer = {0};
  std::array<int, ISuperLayerUtil::c_N> nBackwardArmHitsBySLayer = {0};
 
  // Count the number of hits in the outgoing and ingoing arm per superlayer.
  for (const CDCRecoHit3D& hit : track) {
    if ((hit.getArcLength2D() <= apogeeArcLength) and (hit.getArcLength2D() > 0)) {
      nForwardArmHitsBySLayer[hit.getISuperLayer()]++;
    } else {
      nBackwardArmHitsBySLayer[hit.getISuperLayer()]++;
    }
  }
 
  std::vector<ISuperLayer> forwardSLayerHoles = getSLayerHoles(nForwardArmHitsBySLayer);
  std::vector<ISuperLayer> backwardSLayerHoles = getSLayerHoles(nBackwardArmHitsBySLayer);
 
  // No missing layers
  if (forwardSLayerHoles.empty() and backwardSLayerHoles.empty()) return;
 
  // We only check for holes in the forward arm for now
  // We do not use emptyEndingSLayers here, as it would leave to a severy efficiency drop.
  assert(std::is_sorted(forwardSLayerHoles.begin(), forwardSLayerHoles.end()));
  if (forwardSLayerHoles.empty()) return;
 
  const ISuperLayer breakSLayer = forwardSLayerHoles.front();
 
  auto isInBackwardArm = [apogeeArcLength](const CDCRecoHit3D & recoHit3D) {
    if ((recoHit3D.getArcLength2D() >= apogeeArcLength) or (recoHit3D.getArcLength2D() < 0)) {
      recoHit3D.getWireHit().getAutomatonCell().unsetTakenFlag();
      return true;
    }
    return false;
  };
 
  erase_remove_if(track, isInBackwardArm);
 
  auto isAfterSLayerBreak = [breakSLayer](const CDCRecoHit3D & recoHit3D) {
    recoHit3D.getWireHit().getAutomatonCell().unsetTakenFlag();
    if (recoHit3D.getISuperLayer() >= breakSLayer) {
      recoHit3D.getWireHit().getAutomatonCell().unsetTakenFlag();
      return true;
    }
    return false;
  };
 
  erase_remove_if(track, isAfterSLayerBreak);
}

splitBack2BackTrack()

std::vector< CDCRecoHit3D > splitBack2BackTrack ( TrackingUtilities::CDCTrack & track )

static

Tries to split back-to-back tracks into two different tracks.

Definition at line 211 of file AxialTrackUtil.cc.

{
  std::vector<CDCRecoHit3D> removedHits;
 
  if (track.size() < 5) return removedHits;
  if (not isBack2BackTrack(track)) return removedHits;
 
  Vector2D center = track.getStartTrajectory3D().getGlobalCenter();
  ESign majorArmSign = getMajorArmSign(track, center);
 
  auto isOnMajorArm = [&center, &majorArmSign](const CDCRecoHit3D & hit) {
    return getArmSign(hit, center) == majorArmSign;
  };
 
  auto itFirstMinorArmHit = std::stable_partition(track.begin(),
                                                  track.end(),
                                                  isOnMajorArm);
 
  for (const CDCRecoHit3D& recoHit3D : asRange(itFirstMinorArmHit, track.end())) {
    recoHit3D.getWireHit().getAutomatonCell().setTakenFlag(false);
    removedHits.push_back(recoHit3D);
  }
  track.erase(itFirstMinorArmHit, track.end());
 
  return removedHits;
}

updateRecoHit3D()

void updateRecoHit3D ( const TrackingUtilities::CDCTrajectory2D & trajectory2D, TrackingUtilities::CDCRecoHit3D & hit )

static

update given CDCRecoHit3D with given trajectory

Definition at line 130 of file AxialTrackUtil.cc.

{
  hit = CDCRecoHit3D::reconstructNearest(&hit.getWireHit(), trajectory2D);
 
  // Recalculate the perpS of the hits
  double arcLength2D = hit.getArcLength2D();
  if (arcLength2D < -trajectory2D.getArcLength2DPeriod() / 4.0) {
    arcLength2D += trajectory2D.getArcLength2DPeriod();
  }
  hit.setArcLength2D(arcLength2D);
}

---

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

• tracking/trackFindingCDC/processing/include/AxialTrackUtil.h
• tracking/trackFindingCDC/processing/src/AxialTrackUtil.cc