InDet::InDetAmbiTrackSelectionTool Class Reference

This tool cross checks the hits on a track with the hits already stored in a PRD_AssociationTool. More...

#include <InDetAmbiTrackSelectionTool.h>

Inheritance diagram for InDet::InDetAmbiTrackSelectionTool:

Collaboration diagram for InDet::InDetAmbiTrackSelectionTool:

Public Member Functions
	InDetAmbiTrackSelectionTool (const std::string &, const std::string &, const IInterface *)
virtual	~InDetAmbiTrackSelectionTool ()=default
	default destructor
virtual StatusCode	initialize () override
	standard Athena-Algorithm method
virtual StatusCode	finalize () override
	standard Athena-Algorithm method
virtual std::tuple< Trk::Track *, bool >	getCleanedOutTrack (const Trk::Track *track, const Trk::TrackScore score, Trk::ClusterSplitProbabilityContainer &splitProbContainer, Trk::PRDtoTrackMap &prd_to_track_map, int trackId=-1, int subtrackId=-1) const override

Private Member Functions
Trk::Track *	createSubTrack (const std::vector< const Trk::TrackStateOnSurface * > &tsos, const Trk::Track *track) const
	method to create a new track from a vector of TSOS's

Private Attributes
PublicToolHandle< ITrtDriftCircleCutTool >	m_selectortool {this, "DriftCircleCutTool", "InDet::InDetTrtDriftCircleCutTool"}
	TRT minimum number of drift circles tool- returns allowed minimum number of TRT drift circles.
ToolHandle< Trk::IPRDtoTrackMapTool >	m_assoTool {this, "AssociationTool", "Trk::PRDtoTrackMapTool" }
const SiliconID *	m_detID {nullptr}
	atlas id helper
IntegerProperty	m_minHits {this, "minHits", 5}
	some cut values
IntegerProperty	m_minTRT_Hits {this, "minTRTHits", 0}
int	m_maxShared {0}
IntegerProperty	m_maxSharedModules {this, "maxShared", 1}
IntegerProperty	m_maxTracksPerPRD {this, "maxTracksPerSharedPRD", 2}
IntegerProperty	m_minNotShared {this, "minNotShared", 6}
FloatProperty	m_minScoreShareTracks {this, "minScoreShareTracks", 0.0}
BooleanProperty	m_cosmics {this, "Cosmics", false}
BooleanProperty	m_parameterization {this, "UseParameterization", true}
BooleanProperty	m_doPixelClusterSplitting {this, "doPixelSplitting", false}
FloatProperty	m_sharedProbCut {this, "sharedProbCut", 0.02}
IntegerProperty	m_maxSplitSize {this, "MaximalSplitSize", 49, "A.S.: remove that when solved properly by updating the SplitProb info with isExcluded. A.S.: to be removed once EDM is updated"}

Detailed Description

This tool cross checks the hits on a track with the hits already stored in a PRD_AssociationTool.

Shared hits are allowed to some extent und under certain conditions (e.g. the track score is high enough), additional shared hits are removed if necessary. This tool does not delete any tracks. If the client is going to discard tracks entered into this tool, the tracks have to be deleted by this client.

Author

Martin Siebel Marti.nosp@m.n.Si.nosp@m.ebel@.nosp@m.CERN.nosp@m..ch

Definition at line 46 of file InDetAmbiTrackSelectionTool.h.

Constructor & Destructor Documentation

InDetAmbiTrackSelectionTool()

InDet::InDetAmbiTrackSelectionTool::InDetAmbiTrackSelectionTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 29 of file InDetAmbiTrackSelectionTool.cxx.

                                                                                      :
  base_class(t, n, p)
{
  // compute the number of shared hits from the number of max shared modules
  m_maxShared = 2*m_maxSharedModules+1;
}

~InDetAmbiTrackSelectionTool()

virtual InDet::InDetAmbiTrackSelectionTool::~InDetAmbiTrackSelectionTool ( )

virtualdefault

default destructor

Member Function Documentation

createSubTrack()

Trk::Track * InDet::InDetAmbiTrackSelectionTool::createSubTrack ( const std::vector< const Trk::TrackStateOnSurface * > & tsos, const Trk::Track * track ) const

private

method to create a new track from a vector of TSOS's

Definition at line 534 of file InDetAmbiTrackSelectionTool.cxx.

{
  int nmeas=0;
  for (const Trk::TrackStateOnSurface* tsosIt : tsos) {
    if (tsosIt->type(Trk::TrackStateOnSurface::Measurement)) nmeas++;
  }
  if (nmeas<3) {
    ATH_MSG_DEBUG ("Less than 3 measurements, reject track !");
    return nullptr;
  }
 
  auto vecTsos = std::make_unique<Trk::TrackStates>();
 
  // loop over TSOS, copy TSOS and push into vector
  for (const Trk::TrackStateOnSurface* tsosIt : tsos) {
    const Trk::TrackStateOnSurface* newTsos = new Trk::TrackStateOnSurface(*tsosIt);
    vecTsos->push_back(newTsos);
  }
 
  Trk::TrackInfo info;
  info.addPatternRecoAndProperties(track->info());
  Trk::TrackInfo newInfo;
  newInfo.setPatternRecognitionInfo(Trk::TrackInfo::InDetAmbiTrackSelectionTool);
  info.addPatternReco(newInfo);
 
  Trk::Track* newTrack = new Trk::Track(info, std::move(vecTsos),nullptr);
 
  return newTrack;
 
}

finalize()

StatusCode InDet::InDetAmbiTrackSelectionTool::finalize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 54 of file InDetAmbiTrackSelectionTool.cxx.

{
  return StatusCode::SUCCESS;
}

getCleanedOutTrack()

std::tuple< Trk::Track *, bool > InDet::InDetAmbiTrackSelectionTool::getCleanedOutTrack ( const Trk::Track * track, const Trk::TrackScore score, Trk::ClusterSplitProbabilityContainer & splitProbContainer, Trk::PRDtoTrackMap & prd_to_track_map, int trackId = -1, int subtrackId = -1 ) const

overridevirtual

Definition at line 60 of file InDetAmbiTrackSelectionTool.cxx.

{
  // flag if the track is ok (true) or needs cleaning (false)
  bool TrkCouldBeAccepted        = true;
 
  // some counters used in the logic
  int  numUnused         = 0;
  int  numTRT_Unused     = 0;
  int  numShared         = 0;
  int  numWeightedShared = 0;
  bool thishasblayer     = false;
  bool hassharedblayer   = false;
  bool hassharedpixel    = false;
  bool firstisshared     = true; // logic is that it is set to false if we find a first hit unshared
 
  // let's remember the last 2 ROTs on the track
  const Trk::RIO_OnTrack* lastrot       = nullptr;
  const Trk::RIO_OnTrack* lastbutonerot = nullptr;
  int                     lastrotindex  = 0;
 
  // cut on TRT hits, might use eta dependent cuts here
  int  nCutTRT = m_minTRT_Hits;
  if (m_parameterization) {
    const DataVector<const Trk::TrackParameters>* vpar = ptrTrack->trackParameters();
    const Trk::TrackParameters*                    par = (*vpar)[0];
    // ME bugfix
    int expected = m_selectortool->minNumberDCs(par);
    if (expected > nCutTRT) nCutTRT = expected;
  }
 
  // get all TSOS the track
  const Trk::TrackStates* tsos = ptrTrack->trackStateOnSurfaces();
  ATH_MSG_DEBUG ("Study new Track "<< ptrTrack<<"\t , it has "<<tsos->size()<<"\t track states");
  ATH_MSG_DEBUG ("trackId "<< trackId <<", subtrackId "<<subtrackId);
 
  // is this a track from the pattern or a fitted track ?
  bool ispatterntrack = (ptrTrack->info().trackFitter()==Trk::TrackInfo::Unknown);
  if (ispatterntrack) {
    ATH_MSG_DEBUG ("==> this is a pattern track, outliers are good hits (reintegration) !");
  } else {
    ATH_MSG_DEBUG ("==> this is a refitted track, so we can use the chi2 ! ");
  }
 
  // some pre-processing of the summary information, if available, needed for special cuts
  int nPixelDeadSensor = -1;
  int nSCTDeadSensor   = -1;
  int npixel    = 0;
  int npixholes = 0;
  int nsctholes = 0;
  const Trk::TrackSummary* trkSummary=ptrTrack->trackSummary();
  if (trkSummary) {
    ATH_MSG_VERBOSE ("---> Found summary information");
    nPixelDeadSensor = trkSummary->get(Trk::numberOfPixelDeadSensors);
    nSCTDeadSensor   = trkSummary->get(Trk::numberOfSCTDeadSensors);
    npixel           = trkSummary->get(Trk::numberOfPixelHits);
    npixholes        = trkSummary->get(Trk::numberOfPixelHoles);
    nsctholes        = trkSummary->get(Trk::numberOfSCTHoles);
  }
  // set nDeadSensors to 0 in case trkSummary wasn't called with HoleSearch
  // (i.e. number of deadSensors not available)
  if (nPixelDeadSensor == -1) nPixelDeadSensor = 0;
  if (nSCTDeadSensor   == -1) nSCTDeadSensor   = 0;
  ATH_MSG_VERBOSE ("---> Number of dead si sensors: " << nPixelDeadSensor + nSCTDeadSensor);
 
  // possible classification of TSOS
  enum TsosTypes {
    // A measurement not yet used in any other track
    UnusedHit   = 1,
    // A measurement shared with another track
    SharedHit   = 2,
    // A hit that needs to be removed from the track
    RejectedHit = 3,
    // an outlier, to be copied in case
    Outlier     = 4,
    // other TSOS types to be copied in case
    OtherTsos   = 5
  };
  // create an array of types for each TSOS
  std::vector<int> tsosType;
  tsosType.resize(tsos->size());
 
  // loop over TSOS
  Trk::TrackStates::const_iterator iTsos    = tsos->begin();
  Trk::TrackStates::const_iterator iTsosEnd = tsos->end();
  for (int index = 0 ; iTsos != iTsosEnd ; ++iTsos, ++index) {
 
    // init array
    tsosType[index] = OtherTsos;
 
    // get measurment from TSOS
    const Trk::MeasurementBase* meas = (*iTsos)->measurementOnTrack();
 
    // if we do not have a measurement, we should just mark it
    if (!meas) {
      ATH_MSG_VERBOSE ("-> No measurement on TSOS, it is another type, to be copied over");
      tsosType[index] = OtherTsos;
      continue;
    }
 
    // ok, let try to get the ROT then
    const Trk::RIO_OnTrack* rot = dynamic_cast <const Trk::RIO_OnTrack*> (meas);
    if (!rot) {
      // could be a Pseudo-Measurement ?
      const Trk::PseudoMeasurementOnTrack* pseudo = dynamic_cast <const Trk::PseudoMeasurementOnTrack*> (meas);
      if (pseudo){
        ATH_MSG_VERBOSE ("-> Copy pseudo measurement");
      } else {
        ATH_MSG_WARNING ("-> Measurement is not a pseudo measurment, not yet supported, try to copy !");
      }
      tsosType[index] = OtherTsos;
      continue;
    }
 
    //
    // we have a TSOS with a measurement, keep analysing it
    //
 
    // let's get some information about the measurement
    const Identifier& id = rot->identify();
    bool isTRT           = m_detID->is_trt(id);
    bool isPixel         = m_detID->is_pixel(id);
    bool isBlayer        = isPixel ? m_detID->is_blayer(id) : false;
    bool isoutlier       = (*iTsos)->type(Trk::TrackStateOnSurface::Outlier);
 
    // do we have some b-layer hit here (sorting of TSOS is inside out)
    if (isBlayer && (!isoutlier || ispatterntrack)) thishasblayer = true;  // we may reintegrate outliers from pattern
 
    // special cut to remove problematic combinations in the pixels
    if ( isPixel && !thishasblayer && npixholes>0           &&  // a pixel hit, no b-layer, we do have pixel holes
         ( ( npixel==1 && !isoutlier ) ||                       // one pixel on track, it is not an additional outlier
           ( ispatterntrack && npixel==0 && isoutlier) )   ) {  // pattern track, no pixels, but an outlier (we may reintegrate it)
      ATH_MSG_VERBOSE ("-> Special case, problematic single pixel hit on track, reject it !");
      tsosType[index]    = RejectedHit;
      // mark track as bad !
      TrkCouldBeAccepted = false;
      continue;
    }
 
    // do we have an outlier (an not a pattern track) ?
    // if ( (isoutlier && !ispatterntrack) || !(m_detID->is_indet(id)) ) {
    if ( (isoutlier && !ispatterntrack) || !(m_detID->is_indet(id)) ) {
      ATH_MSG_VERBOSE ("-> Prd is outlier on a fitter track (or not InDet), copy it over");
      tsosType[index] = Outlier;
      continue;
    }
 
    // let's check if this is a shared hit (even if it is an outlier on a pattern track) ?
    if (!prd_to_track_map.isUsed(*(rot->prepRawData()))) {
      if ( !isoutlier ) {
        ATH_MSG_VERBOSE ("-> Prd is unused, copy it over");
      } else {
        ATH_MSG_VERBOSE ("-> Prd is outlier on a pattern track and is unused, copy it over");
      }
 
      tsosType[index] = UnusedHit;
      // increase some counters
      if (isTRT) numTRT_Unused++;
      else numUnused++;
      // remember if first hit is shared, we need that later
      if (numShared == 0) firstisshared = false;
      // remember the last 2 ROTs
      lastbutonerot = lastrot;
      lastrot       = rot;
      lastrotindex  = index;
 
      continue;
    }
 
    //
    // ok, we have a shared hit
    //
 
    // do we have an outlier and a pattern track, but the hit is shared, so reject it (we reintegrate it otherwise)
    if ( isoutlier && ispatterntrack ) {
      ATH_MSG_VERBOSE ("-> Shared Prd is outlier on a pattern track, we do not want to reintegrate it, so reject it ");
      tsosType[index]    = RejectedHit;
      // mark track as bad !
      TrkCouldBeAccepted = false;
      continue;
    }
 
    // first check if it is a shared TRT hit, this is not allowed
    if (isTRT) {
      ATH_MSG_VERBOSE ("-> Share TRT hit, drop it !");
      tsosType[index]    = RejectedHit;
      // mark track as bad !
      TrkCouldBeAccepted = false;
      continue;
    }
 
    /* consider hit to be a shared one, if
       - not too many tracks share this hit already
       - the score of the track is high enough to allow for shared hits
    */
    Trk::PRDtoTrackMap::ConstPrepRawDataTrackMapRange range = prd_to_track_map.onTracks(*(rot->prepRawData()));
    int                             numberOfTracksWithThisPrd = std::distance(range.first,range.second);
    ATH_MSG_VERBOSE ("---> number of tracks with this share Prd: " << numberOfTracksWithThisPrd << " maxtracks: " << m_maxTracksPerPRD);
 
    // see if we try keeping it as a shared hit ?
    if ( numberOfTracksWithThisPrd < m_maxTracksPerPRD  && // we do not allow to share with to many tracks
         score > m_minScoreShareTracks                  && // score needs to be good
         (!isPixel || npixholes<=0)                    ) { // we do not share pixels if there are holes in pixels
 
      // special treatment of share split pixel clusters...
      if (m_doPixelClusterSplitting && isPixel) {
        // get pixel cluster
        const InDet::PixelCluster* clus = dynamic_cast <const InDet::PixelCluster*> (rot->prepRawData());
 
        if ( !clus ) {
          ATH_MSG_WARNING ("-----> cast to Pixel cluster failed, should not happen !");
          // mark track as bad !
          TrkCouldBeAccepted = false; // we have to remove at least one PRD
          continue;
        } else {
 
          // split clusters are not allowed to be shared at all, unless
          const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &splitProb = splitProbContainer.splitProbability(clus);
          if ( splitProb.isSplit() )  {
            ATH_MSG_VERBOSE ("-----> Pixel cluster is split, reject shared hit !!!");
            tsosType[index]    = RejectedHit;
            // mark track as bad !
            TrkCouldBeAccepted = false; // we have to remove at least one PRD
            continue;
          }
 
          // is cluster compatible with being a shared cluster ?
          // A.S.: also a hack for the max size: allows large clusters that are exluded from the splitter to be shared
          //       needs isExcluded() flag in the future
          if (splitProb.splitProbability1() < m_sharedProbCut && clus->rdoList().size() <= size_t(m_maxSplitSize) ) {
            ATH_MSG_VERBOSE ("-----> Pixel cluster is not compatible with being shared (splitProb = "
                             << splitProb.splitProbability1() << ") , reject shared hit !!!");
            tsosType[index]    = RejectedHit;
            // mark track as bad !
            TrkCouldBeAccepted = false; // we have to remove at least one PRD
            continue;
          }
        }
      }
 
      ATH_MSG_VERBOSE ("---> Shared hit, but good track, let's enter hit in the list and try to keep it !");
      tsosType[index]   = SharedHit;
      numShared++;                             // increase counter
      numWeightedShared += (isPixel ? 2 : 1);  // increase counter
 
      // some additional bookkeeping, we need this later
      if (isPixel) {
        // ME: bugfix, either shared blayer or shared pixel
        if (isBlayer) hassharedblayer = true;
        else  hassharedpixel = true;
      }
      // remember the last 2 ROTs
      lastbutonerot = lastrot;
      lastrot       = rot;
      lastrotindex  = index;
 
      continue;
    }
 
    // ok, we failed to keep the share hit, let's reject it.
    ATH_MSG_VERBOSE ("---> Share hit and bad track, reject it !");
    tsosType[index]    = RejectedHit;
    // mark track as bad !
    TrkCouldBeAccepted = false; // we have to remove at least one PRD
  }
 
  // total number of hits with dead modules
  int totalSiHits = numUnused + nPixelDeadSensor + nSCTDeadSensor;
 
  // special cut, do not allow the last hit to be to far away or after to many holes
  if (ispatterntrack                                                                              && // pattern track and
      totalSiHits > m_minHits                                                                     && // we have enough hits on the track
      (lastrot && lastbutonerot)                                                                  && // has enough ROTs
      (lastrot->globalPosition()-lastbutonerot->globalPosition()).mag()>1000*CLHEP::mm) { // distance cut
    ATH_MSG_DEBUG ("Special cut on distance, reject last hit on track !");
    tsosType[lastrotindex] = RejectedHit;
    numUnused--; // update counter
    // mark track as bad !
    TrkCouldBeAccepted     = false;
  }
 
  // special cut, do not allow the last hit to be after to many holes
  if (ispatterntrack                                                                              && // pattern track and
      totalSiHits > m_minHits                                                                     && // we have enough hits on the track
      nsctholes>3 ) { // too many holes cut
    ATH_MSG_DEBUG ("Special cut on too many holes, reject last hit on track !");
    tsosType[lastrotindex] = RejectedHit;
    numUnused--; // update counter
    // mark track as bad !
    TrkCouldBeAccepted     = false;
  }
 
 
 
  // get chi2/NDF, if track is fitted
  if ( !ispatterntrack ) {
    double trackchi2 = 0.;
    if  (ptrTrack->fitQuality() && ptrTrack->fitQuality()->numberDoF()>0 )
      trackchi2 = ptrTrack->fitQuality()->chiSquared()/ptrTrack->fitQuality()->numberDoF();
 
    // if we have share hits and this is a bad track, we reject it
    if ( numShared > 0 && !ispatterntrack && trackchi2 > 3 ) {
      ATH_MSG_DEBUG ("Shared hits, we have a bad chi2 track, mark it as bad !");
      // mark track as bad !
      TrkCouldBeAccepted = false;
    }
  }
 
 
  // numTRT cut, special for back tracking
  if ( numTRT_Unused < nCutTRT) {
    ATH_MSG_DEBUG ("Track fails TRT hit cut, mark it as bad !");
    // mark track as bad !
    TrkCouldBeAccepted = false;
  }
 
  //
  // now see what to do with the track
  //
 
  // best case, we like this track and it passes this complex if statement
  if ( TrkCouldBeAccepted                                                    && // we did not mark the track as bad before
       ( !hassharedblayer || npixholes<=1 )                                  && // if blayer, at most 1 pixel hole
       !hassharedpixel                                                       && // no shared pixel hits
       ( ( totalSiHits >= m_minHits      && numShared == 0 )                 || // no shared and enough hits OR
         ( totalSiHits >= m_minNotShared && numWeightedShared <= m_maxShared && // shared hits and enough unique hits and shared hits with good quality
           ( totalSiHits + std::min(numShared,m_maxShared) ) >= m_minHits && score > m_minScoreShareTracks ) ) ) {
    ATH_MSG_DEBUG ("=> Suggest to keep track with "<<numShared<<" shared hits !");
    return std::make_tuple(static_cast<Trk::Track *>(nullptr),true); // keep input track
 
    // ok, failed that one, can we recover the track ?
  } else if ( numTRT_Unused >= nCutTRT           && // TRT track or no TRT at all (back tracking)
              ( totalSiHits >= m_minHits         || // we have enough hits OR
                ( totalSiHits >= m_minNotShared  && // shared hits and enough unique hits and shared hits with good quality
                  totalSiHits+std::min(numShared,m_maxShared) >= m_minHits && score > m_minScoreShareTracks ) ) ) {
    // catch, if this is cosmics, accept the incoming track
    if (m_cosmics) {
      ATH_MSG_DEBUG ("=> Cosmics, accept input track even with shared hits");
      return std::make_tuple(static_cast<Trk::Track *>(nullptr),true); // keep input track;
    }
 
    // if ( numShared == 0 && TrkCouldBeAccepted ) {
    // ATH_MSG_DEBUG ("=> Nothing to recover from, drop track !");
    // return std::make_tuple(static_cast<Trk::Track *>(nullptr),false); // reject input track;
    // }
 
    // Track is potentially ok, create a stripped down version from the unused hits and the allowed shared hits
    // join shared to unused hits, if requirements are met
 
    ATH_MSG_VERBOSE ("Trying to recover track, allow for some shared hits is possible.");
 
    // new TSOS vector
    std::vector<const Trk::TrackStateOnSurface*> newTSOS;
 
    // counter for the weighted number of added shared hits
    int cntIns = 0;
 
    // loop over all TSOS (and types) and copy the good ones over
    Trk::TrackStates::const_iterator iTsos    = tsos->begin();
    Trk::TrackStates::const_iterator iTsosEnd = tsos->end();
 
    for (int index = 0 ; iTsos != iTsosEnd ; ++iTsos,++index ) {
 
      // remove rejected hits
      if (tsosType[index] == RejectedHit) {
        ATH_MSG_VERBOSE ("-> Dropping rejected hit");
 
      } else if (tsosType[index] != SharedHit ) {
        ATH_MSG_VERBOSE ("-> Copy good TSOS");
        newTSOS.push_back(*iTsos);
 
      } else if (cntIns >= m_maxShared) {
        ATH_MSG_VERBOSE ("-> Too many share hits, dropping outer hit(s)");
 
      } else {
        ATH_MSG_VERBOSE ("-> Try to recover a shared hit");
 
        // get measurment from TSOS
        const Trk::MeasurementBase* meas = (*iTsos)->measurementOnTrack();
        // get ROT from this TSOS
        const Trk::RIO_OnTrack*      rot = dynamic_cast <const Trk::RIO_OnTrack*> (meas);
 
        if (!rot) {
          ATH_MSG_WARNING ("Cast to RIO_OnTrack failed, should never happen !");
          continue;
        }
 
        // is it a pixel cluster ?
        bool isPixel = m_detID->is_pixel(rot->identify());
 
        // find out how many tracks use this hit already
        Trk::PRDtoTrackMap::ConstPrepRawDataTrackMapRange range = prd_to_track_map.onTracks(*(rot->prepRawData()));
        int                           numberOfTracksWithThisPrd = std::distance(range.first,range.second);
        ATH_MSG_VERBOSE ("---> number of tracks with this shared Prd: " << numberOfTracksWithThisPrd << " maxtracks: " << m_maxTracksPerPRD);
 
        // check if this newly shared hit would exceed the shared hits limit of the already accepted track (**)
        int  iShared        = 0;
        int  othernpixel    = 0;
        bool otherhasblayer = false;
        if ( numberOfTracksWithThisPrd == 1 ) {
          // @TODO is it ensured that the prds of all tracks have been registered already ?
          std::vector< const Trk::PrepRawData* > prdsToCheck = m_assoTool->getPrdsOnTrack(prd_to_track_map,*(range.first->second));
          for (const Trk::PrepRawData* prd : prdsToCheck) {
            if (prd_to_track_map.isShared(*prd))
              ++iShared;
            if (m_detID->is_pixel(prd->identify())) {
              othernpixel++;
              if (m_detID->is_blayer(prd->identify())) otherhasblayer=true;
            }
          }
        }
 
        // now decide what to do, can we keep the shared hit
        if ( numberOfTracksWithThisPrd < m_maxTracksPerPRD            && // number of tracks sharing hit
             score > m_minScoreShareTracks                            && // score cut
             (!isPixel || !hassharedblayer || npixholes <= 0)         && // shared b-layer only if no pixel holes
             ( iShared < m_maxShared || (isPixel && !firstisshared) ) && // do not allow other accepted track to exceed the shared limit, if first pixel hit is shared
             (!isPixel || thishasblayer == otherhasblayer )           && // only allow shared pixel if both have blayer or both not
             (!isPixel || npixel >= othernpixel )                    ) { // only allow shared pixel if new track as at least as many pixel hits
 
          ATH_MSG_VERBOSE ("---> Accepted hit shared with " << numberOfTracksWithThisPrd << " tracks !");
          newTSOS.push_back(*iTsos);
          numUnused++; // update counter
 
          // update shared hit counter
          cntIns += (isPixel ? 2 : 1);
 
        } else {
          ATH_MSG_VERBOSE ("---> Reject hit shared with " << numberOfTracksWithThisPrd << " tracks !");
        }
      }
    }
 
    // this still may happen per (**) see above.
    if ( numUnused+nPixelDeadSensor+nSCTDeadSensor < m_minHits || newTSOS.size() <= 3 ) {
      ATH_MSG_DEBUG ("=> Too few hits, reject track with shared hits");
      return std::make_tuple(static_cast<Trk::Track *>(nullptr),false); // reject input track;
    }
 
    // check that this is not the input track
    if ( newTSOS.size() == tsos->size() ) {
      ATH_MSG_DEBUG ("=> Recovered input track, accept it !");
      return std::make_tuple(static_cast<Trk::Track *>(nullptr),true); // keep input track;
    } else {
      // ok, done, create subtrack
      Trk::Track* newTrack = createSubTrack(newTSOS,ptrTrack);
      if (!newTrack) {
        ATH_MSG_DEBUG ("=> Failed to create subtrack");
        return std::make_tuple(static_cast<Trk::Track *>(nullptr),false); // reject input track;
      }
 
      Trk::TrackInfo info;
      info.addPatternRecoAndProperties(ptrTrack->info());
      Trk::TrackInfo newInfo;
      newInfo.setPatternRecognitionInfo(Trk::TrackInfo::InDetAmbiTrackSelectionTool);
      info.addPatternReco(newInfo);
      newTrack->info().addPatternReco(ptrTrack->info());
 
      ATH_MSG_DEBUG ("=> Successfully created subtrack with shared hits recovered !");
      return std::make_tuple(newTrack,false); // new cleaned track, reject input track ;
    }
  } else {
    ATH_MSG_DEBUG ("=> Track is recommended to be dropped");
  }
 
  return std::make_tuple(static_cast<Trk::Track *>(nullptr),false); // reject input track;
}

initialize()

StatusCode InDet::InDetAmbiTrackSelectionTool::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 40 of file InDetAmbiTrackSelectionTool.cxx.

{
  // Get segment selector tool
  //
  ATH_CHECK(m_selectortool.retrieve(DisableTool{!m_parameterization}));
  ATH_CHECK(detStore()->retrieve(m_detID, "SiliconID" ));
  ATH_MSG_DEBUG( "initialize() successful" );
 
  ATH_CHECK(m_assoTool.retrieve() );
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_assoTool

ToolHandle<Trk::IPRDtoTrackMapTool> InDet::InDetAmbiTrackSelectionTool::m_assoTool {this, "AssociationTool", "Trk::PRDtoTrackMapTool" }

private

Definition at line 74 of file InDetAmbiTrackSelectionTool.h.

{this, "AssociationTool", "Trk::PRDtoTrackMapTool" };

m_cosmics

BooleanProperty InDet::InDetAmbiTrackSelectionTool::m_cosmics {this, "Cosmics", false}

private

Definition at line 88 of file InDetAmbiTrackSelectionTool.h.

{this, "Cosmics", false};

m_detID

const SiliconID* InDet::InDetAmbiTrackSelectionTool::m_detID {nullptr}

private

atlas id helper

Definition at line 78 of file InDetAmbiTrackSelectionTool.h.

{nullptr};

m_doPixelClusterSplitting

BooleanProperty InDet::InDetAmbiTrackSelectionTool::m_doPixelClusterSplitting {this, "doPixelSplitting", false}

private

Definition at line 90 of file InDetAmbiTrackSelectionTool.h.

{this, "doPixelSplitting", false};

m_maxShared

int InDet::InDetAmbiTrackSelectionTool::m_maxShared {0}

private

Definition at line 83 of file InDetAmbiTrackSelectionTool.h.

{0};

m_maxSharedModules

IntegerProperty InDet::InDetAmbiTrackSelectionTool::m_maxSharedModules {this, "maxShared", 1}

private

Definition at line 84 of file InDetAmbiTrackSelectionTool.h.

{this, "maxShared", 1};

m_maxSplitSize

IntegerProperty InDet::InDetAmbiTrackSelectionTool::m_maxSplitSize {this, "MaximalSplitSize", 49, "A.S.: remove that when solved properly by updating the SplitProb info with isExcluded. A.S.: to be removed once EDM is updated"}

private

Definition at line 92 of file InDetAmbiTrackSelectionTool.h.

{this, "MaximalSplitSize", 49, "A.S.: remove that when solved properly by updating the SplitProb info with isExcluded. A.S.: to be removed once EDM is updated"};

m_maxTracksPerPRD

IntegerProperty InDet::InDetAmbiTrackSelectionTool::m_maxTracksPerPRD {this, "maxTracksPerSharedPRD", 2}

private

Definition at line 85 of file InDetAmbiTrackSelectionTool.h.

{this, "maxTracksPerSharedPRD", 2};

m_minHits

IntegerProperty InDet::InDetAmbiTrackSelectionTool::m_minHits {this, "minHits", 5}

private

some cut values

Definition at line 81 of file InDetAmbiTrackSelectionTool.h.

{this, "minHits", 5};

m_minNotShared

IntegerProperty InDet::InDetAmbiTrackSelectionTool::m_minNotShared {this, "minNotShared", 6}

private

Definition at line 86 of file InDetAmbiTrackSelectionTool.h.

{this, "minNotShared", 6};

m_minScoreShareTracks

FloatProperty InDet::InDetAmbiTrackSelectionTool::m_minScoreShareTracks {this, "minScoreShareTracks", 0.0}

private

Definition at line 87 of file InDetAmbiTrackSelectionTool.h.

{this, "minScoreShareTracks", 0.0};

m_minTRT_Hits

IntegerProperty InDet::InDetAmbiTrackSelectionTool::m_minTRT_Hits {this, "minTRTHits", 0}

private

Definition at line 82 of file InDetAmbiTrackSelectionTool.h.

{this, "minTRTHits", 0};

m_parameterization

BooleanProperty InDet::InDetAmbiTrackSelectionTool::m_parameterization {this, "UseParameterization", true}

private

Definition at line 89 of file InDetAmbiTrackSelectionTool.h.

{this, "UseParameterization", true}; // Use table of min number DCs

m_selectortool

PublicToolHandle<ITrtDriftCircleCutTool> InDet::InDetAmbiTrackSelectionTool::m_selectortool {this, "DriftCircleCutTool", "InDet::InDetTrtDriftCircleCutTool"}

private

TRT minimum number of drift circles tool- returns allowed minimum number of TRT drift circles.

Definition at line 71 of file InDetAmbiTrackSelectionTool.h.

{this, "DriftCircleCutTool", "InDet::InDetTrtDriftCircleCutTool"};

m_sharedProbCut

FloatProperty InDet::InDetAmbiTrackSelectionTool::m_sharedProbCut {this, "sharedProbCut", 0.02}

private

Definition at line 91 of file InDetAmbiTrackSelectionTool.h.

{this, "sharedProbCut", 0.02};

---

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

• InDetAmbiTrackSelectionTool.h
• InDetAmbiTrackSelectionTool.cxx