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...
bool	doubleHolesFilter (const trackProxy_t &track)
	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 contributing pixel layers. More...
bool	etaDependentCuts (const trackProxy_t &track, ServiceHandle< InDet::IInDetEtaDependentCutsSvc > etaDependentCutsSvc)
	Filter for tracks based on eta dependent cuts. More...
void	patternTrackHitSelection (const trackProxy_t &track, const trackProxy_t::ConstTrackStateProxy &ts, Acts::ScoreBasedAmbiguityResolution::TrackStateTypes &trackStateType)
	Hit selection for tracks based on pattern track hits. More...

Typedef Documentation

trackProxy_t

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

Definition at line 27 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 31 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));
  }
 
  unsigned int pixelVoulmeIds[] = {8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20};
 
  for (auto track : updatedTracks) {
    bool doubleFlag = false;
    int nDoubleHoles = 0;
    int nInnermostPixelLayerHits = 0;
    int nContribPixelLayers = 0;
    for (const auto ts : track.trackStatesReversed()) {
      if (!ts.hasReferenceSurface()) {
        continue;
      }
      // Check if the volume is the innermost pixel layer
      // Compute the number of hits in the innermost pixel layer
      auto iVolume = ts.referenceSurface().geometryId().volume();
      if (iVolume == 8) {
        nInnermostPixelLayerHits++;
      }
      if (std::find(std::begin(pixelVoulmeIds), std::end(pixelVoulmeIds),
                    iVolume) != std::end(pixelVoulmeIds)) {
        nContribPixelLayers++;
      }
 
      // 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 contributing pixel layers.

Definition at line 143 of file ScoreBasedSolverCutsImpl.cxx.

                                                                       {
 
  const int maxPixelLayITk = 16;
  auto maxPixLay = maxPixelLayITk;
  double maxScore = 30.0;
  double minScore = 5.00;
  int maxBarrel = 10;
  int minBarrel = 3;
  int minEnd = 5;
 
  double step[2] = {(maxScore - minScore) / (maxBarrel - minBarrel),
                    (maxScore - minScore) / (maxPixelLayITk - minEnd)};
 
  std::vector<double> factorPixLay;
  for (int i = 0; i <= maxPixelLayITk; 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];
  }
}

doubleHolesFilter()

bool ActsTrk::ScoreBasedSolverCutsImpl::doubleHolesFilter

(

const trackProxy_t &

track

)

Filter for tracks based on double holes.

Definition at line 96 of file ScoreBasedSolverCutsImpl.cxx.

                                                  {
 
  int n_doubleHoles = 0;
  int max_doubleHoles = 2;
  Acts::HashedString hash_nMeasSubDet =
      Acts::hashString("nSCTDoubleHoles");
  if (track.container().hasColumn(hash_nMeasSubDet)) {
    n_doubleHoles = track.component<unsigned int>(hash_nMeasSubDet);
  } else {
    return false;
  }
  if (n_doubleHoles > max_doubleHoles) {
    return true;
  }
  return false;
}

etaDependentCuts()

bool ActsTrk::ScoreBasedSolverCutsImpl::etaDependentCuts	(	const trackProxy_t &	track,
		ServiceHandle< InDet::IInDetEtaDependentCutsSvc >	etaDependentCutsSvc
	)

Filter for tracks based on eta dependent cuts.

Definition at line 184 of file ScoreBasedSolverCutsImpl.cxx.

                                                                                                                   {
  auto trackEta = Acts::VectorHelpers::eta(track.momentum());
  auto parm = track.parameters();
 
  double maxEta = etaDependentCutsSvc->getMaxEta();
  if (std::abs(trackEta) > maxEta) {
    return true;
  }
 
  double maxZ0 = etaDependentCutsSvc->getMaxZImpactAtEta(trackEta);
  if (std::abs(parm[Acts::BoundIndices::eBoundLoc1]) > maxZ0) {
    return true;
  }
 
  double maxD0 = etaDependentCutsSvc->getMaxPrimaryImpactAtEta(trackEta);
 
  if (std::abs(parm[Acts::BoundIndices::eBoundLoc0]) > maxD0) {
    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 114 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];
  }
}

patternTrackHitSelection()

void ActsTrk::ScoreBasedSolverCutsImpl::patternTrackHitSelection	(	const trackProxy_t &	track,
		const trackProxy_t::ConstTrackStateProxy &	ts,
		Acts::ScoreBasedAmbiguityResolution::TrackStateTypes &	trackStateType
	)

Hit selection for tracks based on pattern track hits.

Definition at line 209 of file ScoreBasedSolverCutsImpl.cxx.

                                                                      {
  bool ispatternTrack = false;
  Acts::HashedString hash_nMeasSubDet = Acts::hashString("ispatternTrack");
  if (track.container().hasColumn(hash_nMeasSubDet)) {
    ispatternTrack = track.component<unsigned int>(hash_nMeasSubDet);
  }
  if (ts.typeFlags().test(Acts::TrackStateFlag::OutlierFlag) &&
      ispatternTrack) {
    trackStateType =
        Acts::ScoreBasedAmbiguityResolution::TrackStateTypes::RejectedHit;
  } else if (ts.typeFlags().test(Acts::TrackStateFlag::OutlierFlag) &&
             !ispatternTrack) {
    // Copy the hit to the track
    trackStateType =
        Acts::ScoreBasedAmbiguityResolution::TrackStateTypes::Outlier;
  }
}