AmbiguityProcessor Namespace Reference

Typedefs
using	AssociationTool = ToolHandle< Trk::IPRDtoTrackMapTool >
using	AssociationMap = Trk::PRDtoTrackMap
using	DuplicationCheckSet = std::set< std::vector< const Trk::PrepRawData * > >

Enumerations
enum	TrackFilterCategory { ScoreIsZero, TrackIsDuplicate, TrackAccepted, nCategories }

Functions
TrackFilterCategory	categoriseTrack (const Trk::Track &track, const Trk::TrackScore &score, const bool dropDuplicates, const AssociationTool &associate, AssociationMap &map, DuplicationCheckSet &set)
float	calculateFitQuality (const Trk::Track &track)
std::unique_ptr< Trk::Track >	createNewFitQualityTrack (const Trk::Track &track)
int	getUid ()

Typedef Documentation

AssociationMap

using AmbiguityProcessor::AssociationMap = typedef Trk::PRDtoTrackMap

Definition at line 26 of file AmbiguityProcessorUtility.h.

AssociationTool

using AmbiguityProcessor::AssociationTool = typedef ToolHandle<Trk::IPRDtoTrackMapTool>

Definition at line 25 of file AmbiguityProcessorUtility.h.

DuplicationCheckSet

using AmbiguityProcessor::DuplicationCheckSet = typedef std::set<std::vector<const Trk::PrepRawData*> >

Definition at line 27 of file AmbiguityProcessorUtility.h.

Enumeration Type Documentation

TrackFilterCategory

enum AmbiguityProcessor::TrackFilterCategory

Enumerator
ScoreIsZero
TrackIsDuplicate
TrackAccepted
nCategories

Definition at line 24 of file AmbiguityProcessorUtility.h.

{ ScoreIsZero, TrackIsDuplicate, TrackAccepted, nCategories};

Function Documentation

calculateFitQuality()

float AmbiguityProcessor::calculateFitQuality

(

const Trk::Track &

track

)

Definition at line 24 of file AmbiguityProcessorUtility.cxx.

                                             {
    float result{0.0};
    if  (const auto *const quality=track.fitQuality(); quality and quality->numberDoF()>0 ){ 
      result = quality->chiSquared()/quality->numberDoF();
    }
    return result; 
  }

categoriseTrack()

TrackFilterCategory AmbiguityProcessor::categoriseTrack	(	const Trk::Track &	track,
		const Trk::TrackScore &	score,
		const bool	dropDuplicates,
		const AssociationTool &	associate,
		AssociationMap &	map,
		DuplicationCheckSet &	set
	)

Definition at line 15 of file AmbiguityProcessorUtility.cxx.

                                                                                                                                                                                     {
    if (score == 0) return  TrackFilterCategory::ScoreIsZero;
    if (dropDuplicates){
      if(const auto & [p, uniqueTrack] = set.insert(associate->getPrdsOnTrack( map, track)); not uniqueTrack) return TrackFilterCategory::TrackIsDuplicate;
    }
    return TrackFilterCategory::TrackAccepted;
  }

createNewFitQualityTrack()

std::unique_ptr< Trk::Track > AmbiguityProcessor::createNewFitQualityTrack

(

const Trk::Track &

track

)

Definition at line 33 of file AmbiguityProcessorUtility.cxx.

                                                  {
    double reXi2 = 0.; 
    int nDF = 0;
    const Trk::TrackStates* tsos = track.trackStateOnSurfaces();
    auto vecTsos = std::make_unique<Trk::TrackStates>();
    // loop over TSOS, copy TSOS and push into vector
    Trk::TrackStates::const_iterator iTsos    = tsos->begin();
    Trk::TrackStates::const_iterator iTsosEnd = tsos->end(); 
    for ( ; iTsos != iTsosEnd ; ++iTsos) {
      const Trk::TrackStateOnSurface* newTsos = new Trk::TrackStateOnSurface(**iTsos);
      vecTsos->push_back(newTsos);
      if((*iTsos)->type(Trk::TrackStateOnSurface::Measurement)){  //Get the chi2 and number of hits
        if ((*iTsos)->fitQualityOnSurface()) {
          reXi2 += (*iTsos)->fitQualityOnSurface().chiSquared();
          nDF   += (*iTsos)->fitQualityOnSurface().numberDoF();
        }
      }
    }
    auto fq = std::make_unique<Trk::FitQuality>(reXi2,nDF-5);
    Trk::TrackInfo info;
    info.addPatternRecoAndProperties(track.info());
    Trk::TrackInfo newInfo;
    newInfo.setPatternRecognitionInfo(Trk::TrackInfo::SimpleAmbiguityProcessorTool);
    info.addPatternReco(newInfo); 
    return std::make_unique<Trk::Track>(info, std::move(vecTsos), std::move(fq));
  }

getUid()

int AmbiguityProcessor::getUid

(

)

Definition at line 60 of file AmbiguityProcessorUtility.cxx.

               {
    static std::atomic<std::uint32_t> uid { 0 };
    return ++uid;
  }