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 CDCWireHit * > &foundAxialWireHits, const std::vector< const CDCWireHit * > &allAxialWireHits, std::vector< 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 (CDCTrack &track, const std::vector< const CDCWireHit * > &allAxialWireHits)
	Perform all track postprocessing - return whether the track is considered good after the postprocessing.
static void	normalizeTrack (CDCTrack &track)
	Refit and resort the track. Unmask all hits.
static void	updateRecoHit3D (const CDCTrajectory2D &trajectory2D, CDCRecoHit3D &hit)
	update given CDCRecoHit3D with given trajectory
static void	deleteHitsFarAwayFromTrajectory (CDCTrack &track, double maximumDistance=0.2)
	Postprocessing: Delete axial hits that do not "match" to the given track.
static void	assignNewHitsToTrack (CDCTrack &track, const std::vector< const 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< CDCRecoHit3D >	splitBack2BackTrack (CDCTrack &track)
	Tries to split back-to-back tracks into two different tracks.
static bool	isBack2BackTrack (CDCTrack &track)
	Checks whether the track has hits on both arms as seen from the origin.
static ESign	getMajorArmSign (const CDCTrack &track, const 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 CDCTrack &track, const Vector2D &center)
	Calculate the sum of right and left votes for the hits relative to the center.
static void	removeHitsAfterSuperLayerBreak (CDCTrack &track)
	Searches for a break in the super layer chain and remove all hits that come after that.
static ESign	getArmSign (const CDCRecoHit3D &hit, const 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< 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< 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 CDCTrack &track)
	Check track quality – currently based on number of hits only.
static std::vector< ISuperLayer >	getSLayerHoles (const std::array< int, ISuperLayerUtil::c_N > &nHitsBySLayer)
	Helper function getting the empty axial! super layers that appear in the chain of super layers that is supposed to be occupied.
static ISuperLayer	getFirstOccupiedISuperLayer (const std::array< int, 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 ISuperLayer	getLastOccupiedISuperLayer (const std::array< int, 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 32 of file AxialTrackUtil.h.

Member Function Documentation

addCandidateFromHits()

void addCandidateFromHits ( const std::vector< const CDCWireHit * > &  foundAxialWireHits, const std::vector< const CDCWireHit * > &  allAxialWireHits, std::vector< 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 24 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 ( CDCTrack &  track, const std::vector< const 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 175 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 CDCTrack &  track )

staticprivate

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

Definition at line 88 of file AxialTrackUtil.cc.

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

deleteHitsFarAwayFromTrajectory()

void deleteHitsFarAwayFromTrajectory ( 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 140 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< CDCTrack > &  axialTracks, double  minimal_size = 5  )

static

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

Definition at line 196 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< 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 157 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 CDCRecoHit3D &  hit, const 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 281 of file AxialTrackUtil.cc.

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

getArmSignVote()

int getArmSignVote ( const CDCTrack &  track, const 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 256 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, 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 357 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, 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 365 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 CDCTrack &  track, const 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 246 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, 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 337 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 ( CDCTrack &  track )

static

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

Definition at line 236 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 ( CDCTrack &  track )

static

Refit and resort the track. Unmask all hits.

Definition at line 93 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 ( CDCTrack &  track, const std::vector< const CDCWireHit * > &  allAxialWireHits  )

static

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

Definition at line 67 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 ( CDCTrack &  track )

static

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

Definition at line 286 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 ( CDCTrack &  track )

static

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

Definition at line 209 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 CDCTrajectory2D &  trajectory2D, CDCRecoHit3D &  hit  )

static

update given CDCRecoHit3D with given trajectory

Definition at line 128 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