ActsTrk::ScoreBasedSolverCutsImpl Namespace Reference

Typedefs
using	trackProxy_t = ActsTrk::MutableTrackContainer::ConstTrackProxy

Functions
ActsTrk::MutableTrackContainer	addSummaryInformation (ActsTrk::TrackContainer trackContainer)
	Adds summary information to the track container. More...
void	doubleHolesScore (const trackProxy_t &track, double &score)
	Filter for tracks based on double holes. More...
void	innermostPixelLayerHitsScore (const trackProxy_t &track, double &score)
	Score modifier for tracks based on innermost pixel layer hits. More...
void	ContribPixelLayersScore (const trackProxy_t &track, double &score)
	Score modifier for tracks based on number of contributing pixel layers. More...
void	nSCTPixelHitsScore (const trackProxy_t &track, double &score)
	Score modifier for tracks based on number of SCT and pixel hits. More...
bool	etaDependentCuts (const trackProxy_t &track)
	Filter for tracks based on eta dependent cuts. More...

Typedef Documentation

trackProxy_t

using ActsTrk::ScoreBasedSolverCutsImpl::trackProxy_t = typedef ActsTrk::MutableTrackContainer::ConstTrackProxy

Definition at line 26 of file ScoreBasedSolverCutsImpl.h.

Function Documentation

addSummaryInformation()

ActsTrk::MutableTrackContainer ActsTrk::ScoreBasedSolverCutsImpl::addSummaryInformation

(

ActsTrk::TrackContainer

trackContainer

)

Adds summary information to the track container.

Definition at line 77 of file ScoreBasedSolverCutsImpl.cxx.

                                          {
 
  ActsTrk::MutableTrackContainer updatedTracks;
  updatedTracks.ensureDynamicColumns(trackContainer);
 
  updatedTracks.addColumn<unsigned int>("nInnermostPixelLayerHits");
  updatedTracks.addColumn<unsigned int>("nSCTDoubleHoles");
  updatedTracks.addColumn<unsigned int>("nContribPixelLayers");
 
  for (auto track : trackContainer) {
    auto iTrack = track.index();
    auto destProxy = updatedTracks.getTrack(updatedTracks.addTrack());
    destProxy.copyFrom(trackContainer.getTrack(iTrack));
  }
 
  std::vector<unsigned int> pixelBarrelLayerIDs = {9, 16};
 
  unsigned int innermostPixelVolumeID = 9;
  unsigned int innermostPixelLayerID = 2;
 
  for (auto track : updatedTracks) {
    bool doubleFlag = false;
    int nDoubleHoles = 0;
    int nInnermostPixelLayerHits = 0;
    int nContribPixelLayers = 0;
 
    std::vector<unsigned int> contribPixelLayers = {};
 
    for (const auto ts : track.trackStatesReversed()) {
      if (!ts.hasReferenceSurface()) {
        continue;
      }
 
      if (ts.typeFlags().test(Acts::TrackStateFlag::MeasurementFlag)) {
 
        // Check if the volume is the innermost pixel volume
        // Compute the number of hits in the innermost pixel layer
        auto iVolume = ts.referenceSurface().geometryId().volume();
        auto iLayer = ts.referenceSurface().geometryId().layer();
        // 9 is the volume id for the innermost pixel layer in the barrel
        if (iVolume == innermostPixelVolumeID) {
          if (iLayer == innermostPixelLayerID) {
            nInnermostPixelLayerHits++;
          }
        }
 
        unsigned int remappedLayer = remapLayer(iVolume, iLayer);
        if (remappedLayer != 0) {
          contribPixelLayers.push_back(remappedLayer);
        }
      }
 
      std::set<unsigned int> uniqueSet(contribPixelLayers.begin(),
                                       contribPixelLayers.end());
      nContribPixelLayers = uniqueSet.size();
      // Check if the track state has a hole flag
      // Compute the number of double holes
      auto iTypeFlags = ts.typeFlags();
      if (!iTypeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
        doubleFlag = false;
      }
      if (iTypeFlags.test(Acts::TrackStateFlag::HoleFlag)) {
        if (doubleFlag) {
          nDoubleHoles++;
          doubleFlag = false;
        } else {
          doubleFlag = true;
        }
      }
    }
 
    track.template component<unsigned int>(Acts::hashString(
        "nInnermostPixelLayerHits")) = nInnermostPixelLayerHits;
    track.template component<unsigned int>(
        Acts::hashString("nSCTDoubleHoles")) = nDoubleHoles;
    track.template component<unsigned int>(
        Acts::hashString("nContribPixelLayers")) = nContribPixelLayers;
  }
 
  return updatedTracks;
}

ContribPixelLayersScore()

void ActsTrk::ScoreBasedSolverCutsImpl::ContribPixelLayersScore	(	const trackProxy_t &	track,
		double &	score
	)

Score modifier for tracks based on number of contributing pixel layers.

Definition at line 220 of file ScoreBasedSolverCutsImpl.cxx.

                                                                       {
 
  const int maxPixLay = 16;
  double maxScore = 30.0;
  double minScore = 5.00;
  int maxBarrel = 10;
  int minBarrel = 3;
  int minEnd = 5;
 
  std::vector<double> factorPixLay;
 
  double step[2] = {(maxScore - minScore) / (maxBarrel - minBarrel),
                    (maxScore - minScore) / (maxPixLay - minEnd)};
 
  for (int i = 0; i <= maxPixLay; i++) {
    if (i < minEnd)
      factorPixLay.push_back(0.01 + (i * 0.33));
    else
      factorPixLay.push_back(minScore + ((i - minEnd) * step[1]));
  }
 
  int iPixLay = 0;
 
  Acts::HashedString hash_nMeasSubDet = Acts::hashString("nContribPixelLayers");
  if (track.container().hasColumn(hash_nMeasSubDet)) {
    iPixLay = track.component<unsigned int>(hash_nMeasSubDet);
  } else {
    return;
  }
 
  if (iPixLay > -1 && maxPixLay > 0) {
    if (iPixLay > maxPixLay) {
      score *= (iPixLay - maxPixLay + 1);  // layers are good !
      iPixLay = maxPixLay;
    }
    score *= factorPixLay[iPixLay];
  }
}

doubleHolesScore()

void ActsTrk::ScoreBasedSolverCutsImpl::doubleHolesScore	(	const trackProxy_t &	track,
		double &	score
	)

Filter for tracks based on double holes.

Definition at line 162 of file ScoreBasedSolverCutsImpl.cxx.

                                                                {
  int iDblHoles = 0;
  std::vector<double> factorDblHoles;
 
  const int maxDblHoles = 3;
  const double goodDblHoles[maxDblHoles + 1] = {1., 0.03, 0.007, 0.0003};
  const double fakeDblHoles[maxDblHoles + 1] = {1., 0.09, 0.09, 0.008};
 
  for (int i = 0; i <= maxDblHoles; ++i) {
    factorDblHoles.push_back(goodDblHoles[i] / fakeDblHoles[i]);
  }
 
  Acts::HashedString hash_nMeasSubDet = Acts::hashString("nSCTDoubleHoles");
  if (track.container().hasColumn(hash_nMeasSubDet)) {
    iDblHoles = track.component<unsigned int>(hash_nMeasSubDet);
 
    if (iDblHoles > -1 && maxDblHoles > 0) {
      if (iDblHoles > maxDblHoles) {
        score /= (iDblHoles - maxDblHoles + 1);  // holes are bad !
        iDblHoles = maxDblHoles;
      }
      score *= factorDblHoles[iDblHoles];
    }
  }
}

etaDependentCuts()

bool ActsTrk::ScoreBasedSolverCutsImpl::etaDependentCuts

(

const trackProxy_t &

track

)

Filter for tracks based on eta dependent cuts.

Definition at line 293 of file ScoreBasedSolverCutsImpl.cxx.

                                                 {
  auto eta = Acts::VectorHelpers::eta(track.momentum());
  auto parm = track.parameters();
 
  std::vector<double> etaBins = {-4.0, -2.6, -2.0, 0.0, 2.0, 2.6, 4.0};
  std::vector<double> maxD0 = {10.0, 2.0, 2.0, 2.0, 2.0, 10.0};
  std::vector<double> maxZ0 = {200, 200, 200, 200, 200, 200};
  std::vector<unsigned int> maxDoubleHoles = {2, 2, 2, 2, 2, 2};
  std::vector<unsigned int> minSiClusters = {9, 8, 4, 4, 8, 9};
 
  double maxEta = 4.0;
 
  auto it = std::upper_bound(etaBins.begin(), etaBins.end(), eta);
  if (it == etaBins.begin() || it == etaBins.end()) {
    return false;  // eta out of range
  }
  std::size_t etaBin = std::distance(etaBins.begin(), it) - 1;
 
  if (std::abs(eta) > maxEta) {
    return true;
  }
 
  if (std::abs(parm[Acts::BoundIndices::eBoundLoc1]) > maxZ0[etaBin]) {
    return true;
  }
 
  if (std::abs(parm[Acts::BoundIndices::eBoundLoc0]) > maxD0[etaBin]) {
    return true;
  }
 
  unsigned int numSiClusters = track.nMeasurements();
 
  if (numSiClusters < minSiClusters[etaBin]) {
    return true;
  }
 
  unsigned int numSCTDoubleHoles = 0;
  Acts::HashedString hash_nMeasSubDet = Acts::hashString("nSCTDoubleHoles");
  if (track.container().hasColumn(hash_nMeasSubDet)) {
    numSCTDoubleHoles = track.component<unsigned int>(hash_nMeasSubDet);
  }
 
  if (numSCTDoubleHoles > maxDoubleHoles[etaBin]) {
    return true;
  }
 
  return false;
}

innermostPixelLayerHitsScore()

void ActsTrk::ScoreBasedSolverCutsImpl::innermostPixelLayerHitsScore	(	const trackProxy_t &	track,
		double &	score
	)

Score modifier for tracks based on innermost pixel layer hits.

Definition at line 190 of file ScoreBasedSolverCutsImpl.cxx.

                                                                            {
  int bLayerHits = 0;
  const int maxB_LayerHitsITk = 8;
  auto maxB_LayerHits = maxB_LayerHitsITk;
  const double blayModi[maxB_LayerHitsITk + 1] = {0.25, 4.0, 4.5, 5.0, 5.5,
                                                  6.0,  6.5, 7.0, 7.5};
 
  std::vector<double> factorB_LayerHits;
 
  for (int i = 0; i <= maxB_LayerHits; ++i)
    factorB_LayerHits.push_back(blayModi[i]);
  Acts::HashedString hash_nMeasSubDet =
      Acts::hashString("nInnermostPixelLayerHits");
  if (track.container().hasColumn(hash_nMeasSubDet)) {
    bLayerHits = track.component<unsigned int>(hash_nMeasSubDet);
  } else {
    return;
  }
 
  if (bLayerHits > -1 && maxB_LayerHits > 0) {
    if (bLayerHits > maxB_LayerHits) {
      score *= (bLayerHits - maxB_LayerHits + 1);  // hits are good !
      bLayerHits = maxB_LayerHits;
    }
    score *= factorB_LayerHits[bLayerHits];
  }
}

nSCTPixelHitsScore()

void ActsTrk::ScoreBasedSolverCutsImpl::nSCTPixelHitsScore	(	const trackProxy_t &	track,
		double &	score
	)

Score modifier for tracks based on number of SCT and pixel hits.

Definition at line 261 of file ScoreBasedSolverCutsImpl.cxx.

                                                                  {
 
  const int maxHits = 26;
  double maxScore = 40.0;
  double minScore = 5.00;
  int maxBarrel = 25;
  int minBarrel = 9;
  int minEnd = 12;
 
  int iHits = track.nMeasurements();  // This includes SCT, Pixel and HGTD hits
 
  std::vector<double> factorHits;
 
  double step[2] = {(maxScore - minScore) / (maxBarrel - minBarrel),
                    (maxScore - minScore) / (maxHits - minEnd)};
 
  for (int i = 0; i <= maxHits; i++) {
    if (i < minEnd)
      factorHits.push_back(0.01 + (i * 1.0 / minEnd));
    else
      factorHits.push_back(minScore + ((i - minEnd) * step[1]));
  }
  if (iHits > -1 && maxHits > 0) {
    if (iHits > maxHits) {
      score *= (iHits - maxHits + 1);  // hits are good !
      iHits = maxHits;
    }
    score *= factorHits[iHits];
  }
}