TrackQualityTools Class Reference

Tools to apply post corrections to a track after finding. More...

#include <TrackQualityTools.h>

Public Member Functions
	TrackQualityTools ()=delete
	Static class only.
	TrackQualityTools (const TrackQualityTools &copy)=delete
	Static class only.
TrackQualityTools &	operator= (const TrackQualityTools &)=delete
	Static class only.

Static Public Member Functions
static void	normalizeHitsAndResetTrajectory (CDCTrack &track)
	Update all hits to have a positive perpS, a taken flag and no background flag Also set the trajectory to start from the first hit position and point towards the second hit.
static void	removeHitsAfterCDCWall (CDCTrack &track, double outerCylindricalRFactor=1.1)
	Remove all hits which can not belong to the track, as the particle can not exit and enter the CDC again.
static void	removeHitsIfSmall (CDCTrack &track, unsigned int minimalHits=7)
	Delete a track fully of the number of hits is below minimalHits.
static void	removeHitsAfterLayerBreak (CDCTrack &track, double m_maximumArcLength2DDistance=10)
	Delete all hits after a large layer break.
static void	removeHitsAfterLayerBreak2 (CDCTrack &track)
	Delete all hits after a large layer break.
static void	removeHitsInTheBeginningIfAngleLarge (CDCTrack &track, double maximalAngle=0.7)
	If the angle between two following hits is larger than maximalAngle, delete all hits before (!!) the second hit.
static void	removeHitsIfOnlyOneSuperLayer (CDCTrack &track)
	Remove the whole track if it only consists of one superlayer.
static void	removeHitsOnTheWrongSide (CDCTrack &track)
	Remove all hits that are on the wrong side of the detector (so to say: "beyond the IP").
static void	removeArcLength2DHoles (CDCTrack &track, double m_maximumArcLength2DDistance=10)
	Remove all hits that come after a large hole in the two dimensional arc length.
static void	splitSecondHalfOfTrack (CDCTrack &track, std::vector< CDCTrack > &tracks)
	Trasan did output curlers in split two halves - this method can be used to mimic this.
static void	moveToNextAxialLayer (CDCTrack &track)
	Delete hits of the first superlayer if it is a stereo one (fitting does not work very well when starting with a stereo hit).

Detailed Description

Tools to apply post corrections to a track after finding.

"Removing" of hits means always to mark then as assigned. The deletion has to be done later.

Definition at line 25 of file TrackQualityTools.h.

Member Function Documentation

moveToNextAxialLayer()

void moveToNextAxialLayer ( CDCTrack &  track )

static

Delete hits of the first superlayer if it is a stereo one (fitting does not work very well when starting with a stereo hit).

Definition at line 23 of file TrackQualityTools.cc.

{
  for (const CDCRecoHit3D& recoHit : track) {
    if (recoHit.getStereoKind() == EStereoKind::c_Axial) {
      break;
    } else {
      recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
    }
  }
}

normalizeHitsAndResetTrajectory()

void normalizeHitsAndResetTrajectory ( CDCTrack &  track )

static

Update all hits to have a positive perpS, a taken flag and no background flag Also set the trajectory to start from the first hit position and point towards the second hit.

Definition at line 62 of file TrackQualityTools.cc.

{
  if (track.empty()) return;
 
  CDCTrajectory3D trajectory3D = track.getStartTrajectory3D();
 
  // We reset the trajectory here to start (later) at the newStartPosition of the first hit
  const Vector3D startPosition(0, 0, 0);
  trajectory3D.setLocalOrigin(startPosition);
  trajectory3D.setFlightTime(0);
 
  CDCTrajectory2D trajectory2D = trajectory3D.getTrajectory2D();
 
  // Check if we have to reverse the trajectory. This is done by counting the number of hits
  // with positive and with negative arc length
  unsigned int numberOfPositiveHits = 0;
  for (const CDCRecoHit3D& recoHit : track) {
    const double currentArcLength = trajectory2D.calcArcLength2D(recoHit.getRecoPos2D());
    if (currentArcLength > 0) {
      numberOfPositiveHits++;
    }
  }
  const bool reverseTrajectory = 2 * numberOfPositiveHits < track.size();
 
  if (reverseTrajectory) {
    trajectory3D.reverse();
    trajectory2D.reverse();
  }
 
  double arcLength2DPeriod = trajectory2D.getArcLength2DPeriod();
  for (CDCRecoHit3D& recoHit : track) {
    Vector2D recoPos2D = recoHit.getRLWireHit().reconstruct3D(trajectory2D).xy();
    double arcLength2D = trajectory2D.calcArcLength2D(recoPos2D);
 
    if (arcLength2D < 0) {
      arcLength2D += arcLength2DPeriod;
    }
    recoHit.setArcLength2D(arcLength2D);
    recoHit.getWireHit().getAutomatonCell().unsetAssignedFlag();
    recoHit.getWireHit().getAutomatonCell().setTakenFlag();
  }
 
  // We can now sort by arc length
  track.sortByArcLength2D();
 
  // Set the position to the first hit and let the hits start at arc length of 0
  Vector3D frontPosition = track.front().getRLWireHit().reconstruct3D(trajectory2D);
  double arcLengthOffset = trajectory3D.setLocalOrigin(frontPosition);
  track.setStartTrajectory3D(trajectory3D);
  for (CDCRecoHit3D& recoHit : track) {
    recoHit.shiftArcLength2D(-arcLengthOffset);
  }
 
  // Set the back trajectory to start at the last hit position (and shift if necessary)
  Vector3D backPosition = track.back().getRLWireHit().reconstruct3D(trajectory2D);
  double backArcLength2D = trajectory3D.setLocalOrigin(backPosition);
  if (backArcLength2D < 0) {
    trajectory3D.shiftPeriod(1);
  }
  track.setEndTrajectory3D(trajectory3D);
 
}

removeArcLength2DHoles()

void removeArcLength2DHoles ( CDCTrack &  track, double  m_maximumArcLength2DDistance = 10  )

static

Remove all hits that come after a large hole in the two dimensional arc length.

Definition at line 349 of file TrackQualityTools.cc.

{
  const CDCTrajectory3D& trajectory3D = track.getStartTrajectory3D();
  const CDCTrajectory2D& trajectory2D = trajectory3D.getTrajectory2D();
  const double radius = trajectory2D.getLocalCircle()->absRadius();
 
  if (std::isnan(radius)) {
    return;
  }
 
  double lastArcLength2D = NAN;
  bool removeAfterThis = false;
 
  for (const CDCRecoHit3D& recoHit : track) {
    if (removeAfterThis) {
      recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
      continue;
    }
 
    const double currentArcLength2D = recoHit.getArcLength2D();
    if (not std::isnan(lastArcLength2D)) {
      const double delta = (currentArcLength2D - lastArcLength2D) / radius;
      if (fabs(delta) > m_maximumArcLength2DDistance) {
        removeAfterThis = true;
        recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
        continue;
      }
    }
 
    lastArcLength2D = currentArcLength2D;
  }
}

removeHitsAfterCDCWall()

void removeHitsAfterCDCWall ( CDCTrack &  track, double  outerCylindricalRFactor = 1.1  )

static

Remove all hits which can not belong to the track, as the particle can not exit and enter the CDC again.

The radius of the CDC can be "scaled" with the given factor. Works not very good.

Definition at line 125 of file TrackQualityTools.cc.

{
  const CDCTrajectory2D& trajectory2D = track.getStartTrajectory3D().getTrajectory2D();
  const double radius = trajectory2D.getLocalCircle()->absRadius();
 
  // Curler are allowed to have hits on both arms
  if (trajectory2D.isCurler(outerCylindricalRFactor)) {
    return;
  }
 
  const Vector2D& outerExitWithFactor = trajectory2D.getOuterExit(outerCylindricalRFactor);
 
  double arcLength2DOfExitWithFactor = trajectory2D.calcArcLength2D(outerExitWithFactor);
  if (arcLength2DOfExitWithFactor < 0) {
    arcLength2DOfExitWithFactor += 2 * TMath::Pi() * radius;
  }
  bool removeAfterThis = false;
 
  for (const CDCRecoHit3D& recoHit : track) {
    if (removeAfterThis) {
      recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
      continue;
    }
 
    double currentArcLength2D = recoHit.getArcLength2D();
    if (currentArcLength2D < 0) {
      currentArcLength2D += 2 * TMath::Pi() * radius;
    }
 
    if (currentArcLength2D > arcLength2DOfExitWithFactor) {
      recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
      removeAfterThis = true;
    }
  }
}

removeHitsAfterLayerBreak()

void removeHitsAfterLayerBreak ( CDCTrack &  track, double  m_maximumArcLength2DDistance = 10  )

static

Delete all hits after a large layer break.

Works quite well for finding large "breaks" in the track. Implementation one (it is not sure which one is better in the moment.)

Definition at line 205 of file TrackQualityTools.cc.

{
  const CDCTrajectory3D& trajectory3D = track.getStartTrajectory3D();
  const CDCTrajectory2D& trajectory2D = trajectory3D.getTrajectory2D();
  const double radius = trajectory2D.getLocalCircle()->absRadius();
 
  if (std::isnan(radius)) {
    return;
  }
 
  std::vector<std::vector<const CDCRecoHit3D*>> trackletList;
 
  double lastArcLength2D = NAN;
 
  std::vector<const CDCRecoHit3D*>* currentTracklet = nullptr;
 
  for (const CDCRecoHit3D& recoHit : track) {
    if (currentTracklet == nullptr) {
      trackletList.emplace_back();
      currentTracklet = &(trackletList.back());
    }
 
    const double currentArcLength2D = recoHit.getArcLength2D();
    if (not std::isnan(lastArcLength2D)) {
      const double delta = (currentArcLength2D - lastArcLength2D);
      if (std::fabs(delta) > m_maximumArcLength2DDistance) {
        trackletList.emplace_back();
        currentTracklet = &(trackletList.back());
      }
    }
 
    lastArcLength2D = currentArcLength2D;
 
    currentTracklet->push_back(&recoHit);
  }
 
  if (trackletList.size() > 1) {
    // Throw away the ends if they are too small
    while (trackletList.size() > 0) {
      if (trackletList.back().size() > 4) {
        break;
      }
 
      for (const CDCRecoHit3D* recoHit : trackletList.back()) {
        recoHit->getWireHit().getAutomatonCell().setAssignedFlag();
      }
 
      trackletList.pop_back();
    }
 
    std::reverse(trackletList.begin(), trackletList.end());
 
    while (trackletList.size() > 0) {
      if (trackletList.back().size() > 4) {
        break;
      }
 
      for (const CDCRecoHit3D* recoHit : trackletList.back()) {
        recoHit->getWireHit().getAutomatonCell().setAssignedFlag();
      }
 
      trackletList.pop_back();
    }
  }
}

removeHitsAfterLayerBreak2()

void removeHitsAfterLayerBreak2 ( CDCTrack &  track )

static

Delete all hits after a large layer break.

Works quite well for finding large "breaks" in the track. Implementation two (it is not sure which one is better in the moment.)

Definition at line 161 of file TrackQualityTools.cc.

{
  ILayer lastLayer = -1;
  Vector2D lastWirePosition;
 
  std::vector<std::vector<const CDCRecoHit3D*>> trackletList;
  trackletList.reserve(3);
 
  std::vector<const CDCRecoHit3D*>* currentTracklet = nullptr;
 
  for (const CDCRecoHit3D& recoHit : track) {
    if (currentTracklet == nullptr) {
      trackletList.emplace_back();
      currentTracklet = &(trackletList.back());
    }
 
    const ILayer currentLayer = recoHit.getWire().getICLayer();
    const Vector2D& currentPosition = recoHit.getRecoPos2D();
    if (lastLayer != -1) {
      const ILayer delta = currentLayer - lastLayer;
      const double distance = (currentPosition - lastWirePosition).norm();
      if (abs(delta) > 4 or distance > 50) {
        trackletList.emplace_back();
        currentTracklet = &(trackletList.back());
      }
    }
 
    lastWirePosition = currentPosition;
    lastLayer = currentLayer;
 
    currentTracklet->push_back(&recoHit);
  }
 
  if (trackletList.size() > 1) {
    for (const std::vector<const CDCRecoHit3D*>& tracklet : trackletList) {
      if (tracklet.size() < 5) {
        for (const CDCRecoHit3D* recoHit : tracklet) {
          recoHit->getWireHit().getAutomatonCell().setAssignedFlag();
        }
      }
    }
  }
}

removeHitsIfOnlyOneSuperLayer()

void removeHitsIfOnlyOneSuperLayer ( CDCTrack &  track )

static

Remove the whole track if it only consists of one superlayer.

Definition at line 311 of file TrackQualityTools.cc.

{
  ISuperLayer lastLayer = -1;
  bool deleteTrack = true;
 
  for (const CDCRecoHit3D& recoHit : track) {
    const ISuperLayer currentLayer = recoHit.getISuperLayer();
    if (lastLayer != -1 and lastLayer != currentLayer) {
      deleteTrack = false;
      break;
    }
 
    lastLayer = currentLayer;
  }
 
  if (deleteTrack) {
    for (const CDCRecoHit3D& recoHit : track) {
      recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
    }
  }
}

removeHitsIfSmall()

void removeHitsIfSmall ( CDCTrack &  track, unsigned int  minimalHits = 7  )

static

Delete a track fully of the number of hits is below minimalHits.

Definition at line 271 of file TrackQualityTools.cc.

{
  const bool deleteTrack = track.size() < minimalHits;
 
  if (deleteTrack) {
    for (const CDCRecoHit3D& recoHit : track) {
      recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
    }
  }
}

removeHitsInTheBeginningIfAngleLarge()

void removeHitsInTheBeginningIfAngleLarge ( CDCTrack &  track, double  maximalAngle = 0.7  )

static

If the angle between two following hits is larger than maximalAngle, delete all hits before (!!) the second hit.

Definition at line 282 of file TrackQualityTools.cc.

{
  double lastAngle = NAN;
  bool removeAfterThis = false;
 
  for (const CDCRecoHit3D& recoHit : reversedRange(track)) {
    if (removeAfterThis) {
      recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
      continue;
    }
 
    const double currentAngle = recoHit.getRecoPos2D().phi();
    if (not std::isnan(lastAngle)) {
      const double delta = currentAngle - lastAngle;
      const double normalizedDelta =
        std::min(
          ROOT::Math::VectorUtil::Phi_0_2pi(delta),
          ROOT::Math::VectorUtil::Phi_0_2pi(-delta));
      if (fabs(normalizedDelta) > maximalAngle) {
        removeAfterThis = true;
        recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
      }
    }
 
    lastAngle = currentAngle;
  }
}

removeHitsOnTheWrongSide()

void removeHitsOnTheWrongSide ( CDCTrack &  track )

static

Remove all hits that are on the wrong side of the detector (so to say: "beyond the IP").

Definition at line 333 of file TrackQualityTools.cc.

{
  const CDCTrajectory3D& trajectory3D = track.getStartTrajectory3D();
  const CDCTrajectory2D& trajectory2D = trajectory3D.getTrajectory2D();
 
  // Curler are allowed to have negative arc lengths
  if (trajectory2D.isCurler()) {
    return;
  }
  for (const CDCRecoHit3D& recoHit : track) {
    if (trajectory2D.calcArcLength2D(recoHit.getRecoPos2D()) < 0) {
      recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
    }
  }
}

splitSecondHalfOfTrack()

void splitSecondHalfOfTrack ( CDCTrack &  track, std::vector< CDCTrack > &  tracks  )

static

Trasan did output curlers in split two halves - this method can be used to mimic this.

The new track is automatically added to the list of tracks.

Definition at line 34 of file TrackQualityTools.cc.

{
  const CDCTrajectory3D& trajectory3D = track.getStartTrajectory3D();
  const CDCTrajectory2D& trajectory2D = trajectory3D.getTrajectory2D();
  const double radius = trajectory2D.getLocalCircle()->absRadius();
  const Vector2D& apogee = trajectory2D.getGlobalCircle().apogee();
  double arcLength2DOfApogee = trajectory2D.calcArcLength2D(apogee);
  if (arcLength2DOfApogee < 0) {
    arcLength2DOfApogee += 2 * TMath::Pi() * radius;
  }
 
  CDCTrack splittedCDCTrack;
  splittedCDCTrack.setStartTrajectory3D(trajectory3D);
 
  for (CDCRecoHit3D& recoHit : track) {
    double currentArcLength2D = recoHit.getArcLength2D();
    if (currentArcLength2D < 0) B2INFO("Below 0");
    if (currentArcLength2D > arcLength2DOfApogee) {
      splittedCDCTrack.push_back(recoHit);
      recoHit.getWireHit().getAutomatonCell().setAssignedFlag();
    }
  }
 
  if (splittedCDCTrack.size() > 0) {
    tracks.push_back(splittedCDCTrack);
  }
}

---

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

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