#include <TrackFitter.h>

Inheritance diagram for TrackFitter:

Collaboration diagram for TrackFitter:

Public Member Functions
int	fitTracks (const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, std::vector< FPGATrackSimTrack > &tracks)

const std::vector< FPGATrackSimTrack > &	getMissingHitsCheckTracks ()

	TrackFitter (const FPGATrackSimFitConstantBank nominalbank, const std::vector< const FPGATrackSimFitConstantBank > &droppedLayerbanks, bool guessingHits)

void	setIdentifyBadHit (bool flag)

bool	getIdentifyBadHit () const

void	setPlaneMap (FPGATrackSimPlaneMap const *map)

FPGATrackSimPlaneMap const *	getPlaneMap () const

void	setRegionMap (FPGATrackSimRegionMap const *map)

void	setNorecoveryNhits (int v)

int	getNorecoveryNhits () const

void	setRequireFirst (bool v)

bool	getRequireFirst () const

void	setDoMajority (unsigned int v)

unsigned	getDoMajority () const

void	setDoMissingHitsCheck (bool v)

bool	getDoMissingHitsCheck () const

void	setChi2DofRecoveryMin (float v)

float	getChi2DofRecoveryMin () const

void	setChi2DofRecoveryMax (float v)

float	getChi2DofRecoveryMax () const

void	setDoSecondStage (bool v)

bool	getDoSecondStage () const

void	setIdealCoordFitType (TrackCorrType type)

TrackCorrType	getIdealCoordFitType () const

void	setDoDeltaGPhis (bool v)

bool	getDoDeltaGPhis () const

int	getNFits ()

int	getNFitsMajority ()

int	getNFitsMajoritySCI ()

int	getNFitsMajorityPix ()

int	getNFitsRecovery ()

	TrackFitter (void)

virtual	~TrackFitter (void)

virtual DkfTrack *	fit (const RecTrack *)

bool	msgLvl (const MSG::Level lvl) const
	Test the output level. More...

MsgStream &	msg () const
	The standard message stream. More...

MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...

void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Protected Member Functions
virtual TrkTrackState *	extrapolate (TrkTrackState pTS, TrkPlanarSurface pSB, TrkPlanarSurface *pSE, double J[5][5], double &path)

void	matrixInversion5x5 (double a[5][5])

virtual DkfTrack *	createDkfTrack (const RecTrack *inputTrack)

Protected Attributes
double	m_startB [3] {}

double	m_endB [3] {}

std::vector< int >	m_reMapVector

Private Member Functions
void	resetCounters ()

int	fitTracks (const std::shared_ptr< const FPGATrackSimRoad > &road, std::vector< FPGATrackSimTrack > &tracks)
	Creates tracks from the given road. More...

void	getMissingInfo (const FPGATrackSimRoad &road, int &nMissing, bool &missPixel, bool &missStrip, layer_bitmask_t &missing_mask, layer_bitmask_t &norecovery_mask)

void	makeTrackCandidates (const FPGATrackSimRoad &road, const FPGATrackSimTrack &temp, std::vector< FPGATrackSimTrack > &track_cands)
	Creates a list of track candidates by taking all possible combination of hits in road. More...

FPGATrackSimTrack	recoverTrack (FPGATrackSimTrack const &t, sector_t sector, layer_bitmask_t norecovery_mask, double qoverpt)
	Given a N/N track that has a bad chi2, try to refit the track by taking away a single hit, trying N combinations of N-1/N tracks. More...

void	compute_truth (FPGATrackSimTrack &newtrk) const

void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Private Attributes
bool	m_do2ndStage = false

bool	m_guessinghits = true

TrackCorrType	m_IdealCoordFitType = TrackCorrType::None

bool	m_doDeltaGPhis = false

const int	m_max_ncomb = 10000

unsigned	m_do_majority = 1

bool	m_require_first = true

int	m_norecovery_nhits = -1

bool	m_setDoMissingHitsCheck = false

float	m_Chi2Dof_recovery_min = 40.

float	m_Chi2Dof_recovery_max = 1e30

bool	m_identify_badhit = false

FPGATrackSimPlaneMap const *	m_pmap = nullptr

FPGATrackSimRegionMap const *	m_rmap = nullptr

const FPGATrackSimFitConstantBank *	m_nominalBank

std::vector< const FPGATrackSimFitConstantBank * >	m_droppedLayerBanks

std::vector< FPGATrackSimTrack >	m_tracks_missinghits_track

int	m_idbase = 0

int	m_nfits = 0

int	m_nfits_maj = 0

int	m_nfits_maj_SCT = 0

int	m_nfits_maj_pix = 0

int	m_nfits_rec = 0

int	m_nfits_addrec = 0

std::string	m_nm
	Message source name. More...

boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...

std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...

std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...

std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Detailed Description

Author: Riley Xu riley.nosp@m..xu@.nosp@m.cern..nosp@m.ch

Date: March 3, 2020

This class fits tracks from roads.

Definition at line 24 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

Constructor & Destructor Documentation

◆ TrackFitter() [1/2]

TrackFitter::TrackFitter	(	const FPGATrackSimFitConstantBank *	nominalbank,
		const std::vector< const FPGATrackSimFitConstantBank * > &	droppedLayerbanks,
		bool	guessingHits
	)

Definition at line 25 of file TrackFitter.cxx.

                                                                                                         :
   AthMessaging (Athena::getMessageSvc(), "FPGATrackSimTrackFitter") 
 {
   m_guessinghits = guessingHits;
   m_nominalBank = nominalbank;
  
   if (!m_nominalBank) ATH_MSG_FATAL("Constant bank not set");
   if (!m_guessinghits)
     for (auto bank : droppedLayerbanks) 
       m_droppedLayerBanks.push_back(bank);
 }

◆ TrackFitter() [2/2]

TrackFitter::TrackFitter ( void )

◆ ~TrackFitter()

virtual TrackFitter::~TrackFitter ( void )

virtual

Member Function Documentation

◆ compute_truth()

void TrackFitter::compute_truth ( FPGATrackSimTrack & newtrk ) const

private

Definition at line 427 of file TrackFitter.cxx.

 {
     std::vector<FPGATrackSimMultiTruth> mtv;
  
     for (unsigned layer = 0; layer < m_pmap->getNLogiLayers(); layer++)
     {
         if (t.getHitMap() & (1 << m_pmap->getCoordOffset(layer))) continue; // no hit in this plane
     //Sanity check that we have enough hits.
     if (layer < t.getFPGATrackSimHits().size()) mtv.push_back(t.getFPGATrackSimHits().at(layer).getTruth());
  
         // adjust weight for hits without (and also with) a truth match, so that each is counted with the same weight.
         mtv.back().assign_equal_normalization();
     }
  
     FPGATrackSimMultiTruth mt( std::accumulate(mtv.begin(), mtv.end(), FPGATrackSimMultiTruth(), FPGATrackSimMultiTruth::AddAccumulator()) );
     // frac is then the fraction of the total number of hits on the track attributed to the barcode.
  
     FPGATrackSimMultiTruth::Barcode tbarcode;
     FPGATrackSimMultiTruth::Weight tfrac;
     const bool ok = mt.best(tbarcode, tfrac);
     if (ok)
     {
         t.setEventIndex(tbarcode.first);
         t.setBarcode(tbarcode.second);
         t.setBarcodeFrac(tfrac);
     }
 }

◆ createDkfTrack()

virtual DkfTrack* TrackFitter::createDkfTrack ( const RecTrack * inputTrack )

protectedvirtual

◆ extrapolate()

virtual TrkTrackState* TrackFitter::extrapolate	(	TrkTrackState *	pTS,
		TrkPlanarSurface *	pSB,
		TrkPlanarSurface *	pSE,
		double	J[5][5],
		double &	path
	)

protectedvirtual

◆ fit()

virtual DkfTrack* TrackFitter::fit ( const RecTrack * )

virtual

◆ fitTracks() [1/2]

int TrackFitter::fitTracks	(	const std::shared_ptr< const FPGATrackSimRoad > &	road,
		std::vector< FPGATrackSimTrack > &	tracks
	)

private

Creates tracks from the given road.

Takes all combinations of hits in the road to create track candidates, fits them using the constant bank, and filters them based on the chi2 of the fit.

Definition at line 74 of file TrackFitter.cxx.

 {   
     if (not road){
       ATH_MSG_WARNING("road pointer is null in TrackFitter::fitTracks");
       return FITTRACKS_BAD;
     }
     
     m_tracks_missinghits_track.clear();
  
     double y = 0.0;
     double x = 0.0;
     if (m_IdealCoordFitType != TrackCorrType::None ) {
       y = road->getY();
       x = road->getX();
       ATH_MSG_DEBUG("Attempting to fit Hough road with y = " << y << ", x = " << x << ", sector = " << road->getSector());
     }
  
     // Error checking
     int sector = road->getSector();
     if (sector < 0) {
         ATH_MSG_DEBUG("Bad sector " << sector);
         return FITTRACKS_OK;
     }
     else if (sector >= m_nominalBank->getNSectors()) {
         ATH_MSG_WARNING("Constants for sector " << sector << " don't exist");
         return FITTRACKS_BAD;
     }
     else if (!m_nominalBank->getIsGood(sector)) {
       ATH_MSG_WARNING("Constants for sector " << sector << " are not valid");
       return FITTRACKS_BAD;
     }
  
     // Get info on layers with missing hits
     int nMissing;
     bool missPixel;
     bool missStrip;
     layer_bitmask_t missing_mask;
     layer_bitmask_t norecovery_mask; // mask to prevent majority in planes with multiple hits
     getMissingInfo(*road, nMissing, missPixel, missStrip, missing_mask, norecovery_mask);
     // Create a template track with common parameters filled already for initializing below
     FPGATrackSimTrack temp;
     if(!m_do2ndStage){
       temp.setTrackStage(TrackStage::FIRST);
       temp.setFirstSectorID(road->getSector());
     }
     else{
       temp.setTrackStage(TrackStage::SECOND);
       temp.setSecondSectorID(road->getSector());
     }
     temp.setNLayers(m_pmap->getNLogiLayers());
     temp.setBankID(-1); // TODO
     temp.setPatternID(road->getPID());
     temp.setHitMap(missing_mask);
     temp.setNMissing(nMissing);
     temp.setHoughX(x);
     temp.setHoughY(y);
     temp.setQOverPt(y);
     temp.setTrackCorrType(m_IdealCoordFitType);
     temp.setDoDeltaGPhis(m_doDeltaGPhis);
  
     temp.setSubRegion(road->getSubRegion());
     temp.setHoughXBin(road->getXBin());
     temp.setHoughYBin(road->getYBin());
  
     // Create a list of track candidates by taking all possible combinations of hits in road.
     std::vector<FPGATrackSimTrack> track_cands;
     makeTrackCandidates(*road, temp, track_cands);
  
     // Fit the track candidates
     size_t nFits = std::min((size_t)m_max_ncomb, track_cands.size());
     for (size_t icomb = 0; icomb < nFits; icomb++)
     {
         // Before we start, make sure this track candidate has not been marked as invalid
         // due to combinatorics issues with spacepoints.
         bool ok = track_cands[icomb].isValidCand();
         if (!ok) {
             continue;
         }
         if (nMissing == 0 || m_guessinghits)
         {
             ok = m_nominalBank->linfit(sector, track_cands[icomb], m_do2ndStage);
         }
         else
         {
             unsigned int ic = 0; // this will be the leading coordinate with a missing hit
             for (unsigned int ic = 0; ic < m_pmap->getNCoords(); ic++) {
                 if (!( (missing_mask >> ic) & 0x1)) break; // if we found one, stop
             }
             // banks are indexed by plane, not by coordinate
             ok = m_droppedLayerBanks[m_pmap->getCoordLayer(ic)]->linfit(sector, track_cands[icomb], m_do2ndStage);
         }
  
         if (!ok) {
       continue;
         }
         track_cands[icomb].setOrigChi2(track_cands[icomb].getChi2());
         if (getDoMissingHitsCheck()) {
             if (track_cands[icomb].getNMissing() == 0) { // missing 0 hits, drop hits one at a time and refit!
                 for (unsigned icoord = 0; icoord < m_pmap->getNCoords(); icoord++) { // 9 coordinates to refit, nominally
  
                     FPGATrackSimTrack newtrack = track_cands[icomb];
                     newtrack.setNMissing(1);
                     unsigned int bitmask = ( 1 << m_pmap->getNCoords() ) - 1; // all bits set to 1
                     bitmask &= ~(1 << icoord); // remove this coordinate
                     if (m_pmap->getDim(icoord) == 2) { // if we need to do two coordinates at once
                         bitmask &= ~(1 << (icoord+1)); // remove the next coordinate, too
                         newtrack.setNMissing(2);
                     }
                     newtrack.setHitMap(bitmask); // update bitmask
                     m_nominalBank->linfit(sector, newtrack, m_do2ndStage);
                     m_tracks_missinghits_track.push_back(newtrack);
                     if (m_pmap->getDim(icoord) == 2) {
                         icoord++; // skip 2nd of pixel coordinates so we don't do them twice
                     }
                 }
             }
         }
         tracks.push_back(track_cands[icomb]);
     }
  
     // Increment counters
     m_nfits += nFits;
     if (nMissing > 0)
     {
         m_nfits_maj += nFits;
         if (missPixel) m_nfits_maj_pix += nFits;
         if (missStrip) m_nfits_maj_SCT += nFits;
     }
  
     // Do recovery fits
     if (nMissing == 0) {
         // In the case of m_do_majority > 1, we only do majority fits if ALL full fits fail the chi2 cut
         if (m_do_majority == 1 || (m_do_majority > 1 && !hasGoodFit(tracks, m_Chi2Dof_recovery_min)))
         {
             for (FPGATrackSimTrack & t : tracks)
           if (t.getChi2ndof() > m_Chi2Dof_recovery_min && t.getChi2ndof() < m_Chi2Dof_recovery_max){
         double y(0);
         if (road != nullptr && m_IdealCoordFitType != TrackCorrType::None)
           y = road->getY();
         t = recoverTrack(t, norecovery_mask, sector, y);
  
           }
         }
     }
  
     // Add truth info
     for (FPGATrackSimTrack & t : tracks) {
         compute_truth(t); // match the track to a geant particle using the channel-level geant info in the hit data.
     }
  
     return FITTRACKS_OK;
 }

◆ fitTracks() [2/2]

int TrackFitter::fitTracks	(	const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &	roads,
		std::vector< FPGATrackSimTrack > &	tracks
	)

Definition at line 56 of file TrackFitter.cxx.

                                                                                                                               {
     resetCounters();
     for (const std::shared_ptr<const FPGATrackSimRoad>& cur_road : roads) {
       std::vector<FPGATrackSimTrack> t;
       int isOK = fitTracks(cur_road, t);
       if (isOK != FITTRACKS_OK) return isOK;
       else tracks.insert(tracks.end(), t.begin(), t.end());
     }
     return FITTRACKS_OK;
 }

◆ getChi2DofRecoveryMax()

float TrackFitter::getChi2DofRecoveryMax ( ) const

inline

Definition at line 68 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

68 { return m_Chi2Dof_recovery_max; }

◆ getChi2DofRecoveryMin()

float TrackFitter::getChi2DofRecoveryMin ( ) const

inline

Definition at line 65 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

65 { return m_Chi2Dof_recovery_min; }

◆ getDoDeltaGPhis()

bool TrackFitter::getDoDeltaGPhis ( ) const

inline

Definition at line 77 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

77 { return m_doDeltaGPhis; }

◆ getDoMajority()

unsigned TrackFitter::getDoMajority ( ) const

inline

Definition at line 59 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

59 { return m_do_majority; }

◆ getDoMissingHitsCheck()

bool TrackFitter::getDoMissingHitsCheck ( ) const

inline

Definition at line 62 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

62 { return m_setDoMissingHitsCheck; }

◆ getDoSecondStage()

bool TrackFitter::getDoSecondStage ( ) const

inline

Definition at line 71 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

71 { return m_do2ndStage; }

◆ getIdealCoordFitType()

TrackCorrType TrackFitter::getIdealCoordFitType ( ) const

inline

Definition at line 74 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

74 { return m_IdealCoordFitType; }

◆ getIdentifyBadHit()

bool TrackFitter::getIdentifyBadHit ( ) const

inline

Definition at line 45 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

45 { return m_identify_badhit; }

◆ getMissingHitsCheckTracks()

const std::vector<FPGATrackSimTrack>& TrackFitter::getMissingHitsCheckTracks ( )

inline

Definition at line 34 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

34 {return m_tracks_missinghits_track;}

◆ getMissingInfo()

void TrackFitter::getMissingInfo	(	const FPGATrackSimRoad &	road,
		int &	nMissing,
		bool &	missPixel,
		bool &	missStrip,
		layer_bitmask_t &	missing_mask,
		layer_bitmask_t &	norecovery_mask
	)

private

Definition at line 234 of file TrackFitter.cxx.

 {
     nMissing = m_pmap->getNCoords(); // init with nCoords and decrement as we find misses
     missPixel = false;
     missStrip = false;
     missing_mask = 0;
     norecovery_mask = 0;
     unsigned int wclayers = road.getWCLayers();
     for (unsigned layer = 0; layer < m_pmap->getNLogiLayers(); layer++)
     {
         int nHits = road.getHits(layer).size();
         if (nHits==0)
         {
             if (m_IdealCoordFitType == TrackCorrType::None && ((wclayers >> layer) & 1))
             {
                 int ix = m_pmap->getCoordOffset(layer);
                 int iy = ix + 1;
                 if (m_pmap->isSCT(layer))
                 {
                     missing_mask |= 1 << ix;
                     nMissing -= 1;
                 }
                 else
                 {
                     missing_mask |= (1<<ix) | (1<<iy);
                     nMissing -= 2;
                 }
             }
             else
             {
                 if (m_pmap->isSCT(layer)) missStrip = true;
                 else missPixel = true;
             }
         }
         else if (!((wclayers >> layer) & 1)) { // we have a hit
             int ix = m_pmap->getCoordOffset(layer);
             int iy = ix + 1;
             if (m_pmap->isSCT(layer))
           {
                 missing_mask |= 1 << ix;
                 nMissing -= 1;
           }
             else
           {
                 missing_mask |= (1<<ix) | (1<<iy);
                 nMissing -= 2;
           }
  
             // set the mask to avoid recovery in crowded planes
             if (m_norecovery_nhits != -1 && nHits > m_norecovery_nhits)
                 norecovery_mask |= (1<<layer);
         }
     }
 }

◆ getNFits()

int TrackFitter::getNFits ( )

inline

Definition at line 82 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

82 { return m_nfits; }

◆ getNFitsMajority()

int TrackFitter::getNFitsMajority ( )

inline

Definition at line 83 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

83 { return m_nfits_maj; }

◆ getNFitsMajorityPix()

int TrackFitter::getNFitsMajorityPix ( )

inline

Definition at line 85 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

85 { return m_nfits_maj_pix; }

◆ getNFitsMajoritySCI()

int TrackFitter::getNFitsMajoritySCI ( )

inline

Definition at line 84 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

84 { return m_nfits_maj_SCT; }

◆ getNFitsRecovery()

int TrackFitter::getNFitsRecovery ( )

inline

Definition at line 86 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

86 { return m_nfits_rec; }

◆ getNorecoveryNhits()

int TrackFitter::getNorecoveryNhits ( ) const

inline

Definition at line 53 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

53 { return m_norecovery_nhits; }

◆ getPlaneMap()

FPGATrackSimPlaneMap const* TrackFitter::getPlaneMap ( ) const

inline

Definition at line 48 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

48 { return m_pmap; }

◆ getRequireFirst()

bool TrackFitter::getRequireFirst ( ) const

inline

Definition at line 56 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

56 { return m_require_first; }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

 {
   m_imsg = Athena::getMessageSvc();
   m_lvl = m_imsg ?
     static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
     MSG::INFO;
 }

◆ makeTrackCandidates()

void TrackFitter::makeTrackCandidates	(	const FPGATrackSimRoad &	road,
		const FPGATrackSimTrack &	temp,
		std::vector< FPGATrackSimTrack > &	track_cands
	)

private

Creates a list of track candidates by taking all possible combination of hits in road.

Sets basic ID info and hits.

NB: If the number of combinations becomes large and memory is a concern, it may be worth turning this function into a sort of iterator over combs, return a single track each call.

Definition at line 300 of file TrackFitter.cxx.

 {
     std::vector<std::vector<int>> combs = getComboIndices(road.getNHits_layer());
     track_cands.resize(combs.size(), temp);
     //
     //get the WC hits:
     layer_bitmask_t wcbits= road.getWCLayers();
     // Add the hits from each combination to the track, and set ID
     for (size_t icomb = 0; icomb < combs.size(); icomb++)
     {
       //Need to set the ID and the hits size of this track
       track_cands[icomb].setTrackID(m_idbase + icomb);
       track_cands[icomb].setNLayers(m_pmap->getNLogiLayers());
  
       // If this is an idealized coordinate fit; keep references to the idealized radii.
       track_cands[icomb].setIdealRadii(m_rmap->getAvgRadii(0));
  
         std::vector<int> const & hit_indices = combs[icomb]; // size nLayers
         for (unsigned layer = 0; layer < m_pmap->getNLogiLayers(); layer++)
         {
             if (hit_indices[layer] < 0) // Set a dummy hit if road has no hits in this layer
             {
                 FPGATrackSimHit newhit=FPGATrackSimHit();
                 newhit.setLayer(layer);
                 newhit.setSection(0);
                 if (m_pmap->getDim(layer) == 2) newhit.setDetType(SiliconTech::pixel);
                 else newhit.setDetType(SiliconTech::strip);
  
                 if (wcbits & (1 << layer ) ) {
                     newhit.setHitType(HitType::wildcard);
             newhit.setLayer(layer);
         }
                 
                 track_cands[icomb].setFPGATrackSimHit(layer, newhit);
             }
             else
             {
                 const std::shared_ptr<const FPGATrackSimHit> hit = road.getHits(layer)[hit_indices[layer]];
                 // If this is an outer spacepoint, and it is not the same as the inner spacepoint, reject it.
                 // Here we "reject" it by marking the candidate as "invalid", to be rejected later.
                 // That require another field on the track object, but it avoids having to change the sizes
                 // of arrays computed above.
                 if (hit->getHitType() == HitType::spacepoint && (hit->getPhysLayer() % 2) == 1) {
                     const FPGATrackSimHit inner_hit = track_cands[icomb].getFPGATrackSimHits().at(layer - 1);
                     if ((hit->getX() != inner_hit.getX()) || (hit->getY() != inner_hit.getY()) || (hit->getZ() != inner_hit.getZ())) {
                         track_cands[icomb].setValidCand(false);
                     }
                 }
                 track_cands[icomb].setFPGATrackSimHit(layer, *hit);               
             }
         }
     }
  
     m_idbase += combs.size();
 }

◆ matrixInversion5x5()

void TrackFitter::matrixInversion5x5 ( double a[5][5] )

protected

◆ msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 164 of file AthMessaging.h.

 {
   MsgStream* ms = m_msg_tls.get();
   if (!ms) {
     if (!m_initialized.test_and_set()) initMessaging();
     ms = new MsgStream(m_imsg,m_nm);
     m_msg_tls.reset( ms );
   }
  
   ms->setLevel (m_lvl);
   return *ms;
 }

◆ msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 179 of file AthMessaging.h.

180 { return msg() << lvl; }

◆ msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns: boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

 {
   if (!m_initialized.test_and_set()) initMessaging();
   if (m_lvl <= lvl) {
     msg() << lvl;
     return true;
   } else {
     return false;
   }
 }

◆ recoverTrack()

FPGATrackSimTrack TrackFitter::recoverTrack	(	FPGATrackSimTrack const &	t,
		sector_t	sector,
		layer_bitmask_t	norecovery_mask,
		double	qoverpt
	)

private

Given a N/N track that has a bad chi2, try to refit the track by taking away a single hit, trying N combinations of N-1/N tracks.

Returns the track with the best chi2 (or the original track if none of the N-1/N tracks are an improvement).

Parameters

norecovery_mask - will skip removing hits from layers with bit set in this mask

Definition at line 365 of file TrackFitter.cxx.

 {
     m_nfits_rec += 1;
  
     std::vector<FPGATrackSimTrack> recovered_tracks(m_pmap->getNLogiLayers(),t); // start with the complete track in all layers
  
     float best_chi2ndof = t.getChi2ndof();
     int best_i = -1;
  
     // Remove a hit from each layer and do a fit
     for (unsigned layer = (m_require_first ? 1 : 0); layer < recovered_tracks.size(); ++layer)
     {
         // Skip planes with multiple hits
         if (norecovery_mask & (1<<layer)) continue;
         m_nfits_addrec += 1;
         // Zero the cluster for the missing layer, make sure to set the number of dimensions for it
         
         FPGATrackSimHit newhit=FPGATrackSimHit();
         newhit.setLayer(layer);
         newhit.setSection(0);
         newhit.setHitType(HitType::guessed);
         recovered_tracks[layer].setFPGATrackSimHit(layer,newhit);
         // Set the number of missing points and the related bitmask
         int ix = m_pmap->getCoordOffset(layer);
  
         unsigned int missing_mask = t.getHitMap();
         missing_mask &= ~(1 << ix);
  
         if (m_pmap->isPixel(layer)) missing_mask &= ~(1 << (ix + 1));
  
         recovered_tracks[layer].setHitMap(missing_mask);
         recovered_tracks[layer].setNMissing(t.getNMissing() + m_pmap->getDim(layer));
  
     // reset the pt
     recovered_tracks[layer].setQOverPt(qoverpt);
     recovered_tracks[layer].setTrackCorrType(m_IdealCoordFitType);
  
  
         // If not guessing do the fit using layer+1 since 1st set of constants are the 8/8
     if (m_guessinghits) m_nominalBank->linfit(sector, recovered_tracks[layer], m_do2ndStage);
     else m_droppedLayerBanks[layer]->linfit(sector, recovered_tracks[layer], m_do2ndStage);
  
  
         // Check if the chi2ndof is better
         if (recovered_tracks[layer].getChi2ndof() < best_chi2ndof)
         {
             best_chi2ndof = recovered_tracks[layer].getChi2ndof();
             best_i = layer;
         }
     }
  
     if (best_i >= 0)  {// a better track was found
         return recovered_tracks[best_i];
     } else
         return t;
 }

◆ resetCounters()

void TrackFitter::resetCounters ( )

private

Definition at line 39 of file TrackFitter.cxx.

 {
     m_idbase = 0;
     m_nfits = 0;
     m_nfits_maj = 0;
     m_nfits_maj_pix = 0;
     m_nfits_maj_SCT = 0;
     m_nfits_rec = 0;
     m_nfits_addrec = 0;
 }

◆ setChi2DofRecoveryMax()

void TrackFitter::setChi2DofRecoveryMax ( float v )

inline

Definition at line 67 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

67 { m_Chi2Dof_recovery_max = v; }

◆ setChi2DofRecoveryMin()

void TrackFitter::setChi2DofRecoveryMin ( float v )

inline

Definition at line 64 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

64 { m_Chi2Dof_recovery_min = v; }

◆ setDoDeltaGPhis()

void TrackFitter::setDoDeltaGPhis ( bool v )

inline

Definition at line 76 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

76 { m_doDeltaGPhis = v; }

◆ setDoMajority()

void TrackFitter::setDoMajority ( unsigned int v )

inline

Definition at line 58 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

58 { m_do_majority = v; }

◆ setDoMissingHitsCheck()

void TrackFitter::setDoMissingHitsCheck ( bool v )

inline

Definition at line 61 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

61 { m_setDoMissingHitsCheck = v; }

◆ setDoSecondStage()

void TrackFitter::setDoSecondStage ( bool v )

inline

Definition at line 70 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

70 { m_do2ndStage = v; }

◆ setIdealCoordFitType()

void TrackFitter::setIdealCoordFitType ( TrackCorrType type )

inline

Definition at line 73 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

73 {m_IdealCoordFitType = type;}

◆ setIdentifyBadHit()

void TrackFitter::setIdentifyBadHit ( bool flag )

inline

Definition at line 44 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

44 { m_identify_badhit = flag; }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

 {
   m_lvl = lvl;
 }

◆ setNorecoveryNhits()

void TrackFitter::setNorecoveryNhits ( int v )

inline

Definition at line 52 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

52 { m_norecovery_nhits = v; }

◆ setPlaneMap()

void TrackFitter::setPlaneMap ( FPGATrackSimPlaneMap const * map )

inline

Definition at line 47 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

47 { m_pmap = map; }

◆ setRegionMap()

void TrackFitter::setRegionMap ( FPGATrackSimRegionMap const * map )

inline

Definition at line 50 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

50 { m_rmap = map; }

◆ setRequireFirst()

void TrackFitter::setRequireFirst ( bool v )

inline

Definition at line 55 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

55 { m_require_first = v; }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_Chi2Dof_recovery_max

float TrackFitter::m_Chi2Dof_recovery_max = 1e30

private

Definition at line 107 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_Chi2Dof_recovery_min

float TrackFitter::m_Chi2Dof_recovery_min = 40.

private

Definition at line 106 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_do2ndStage

bool TrackFitter::m_do2ndStage = false

private

Definition at line 92 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_do_majority

unsigned TrackFitter::m_do_majority = 1

private

Definition at line 99 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_doDeltaGPhis

bool TrackFitter::m_doDeltaGPhis = false

private

Definition at line 95 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_droppedLayerBanks

std::vector<const FPGATrackSimFitConstantBank*> TrackFitter::m_droppedLayerBanks

private

Definition at line 128 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_endB

double TrackFitter::m_endB[3] {}

protected

Definition at line 24 of file TrigAccel/TrigCudaFitter/src/TrackFitter.h.

◆ m_guessinghits

bool TrackFitter::m_guessinghits = true

private

Definition at line 93 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_idbase

int TrackFitter::m_idbase = 0

private

Definition at line 134 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_IdealCoordFitType

TrackCorrType TrackFitter::m_IdealCoordFitType = TrackCorrType::None

private

Definition at line 94 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_identify_badhit

bool TrackFitter::m_identify_badhit = false

private

Definition at line 110 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_max_ncomb

const int TrackFitter::m_max_ncomb = 10000

private

Definition at line 98 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nfits

int TrackFitter::m_nfits = 0

private

Definition at line 135 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_nfits_addrec

int TrackFitter::m_nfits_addrec = 0

private

Definition at line 140 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_nfits_maj

int TrackFitter::m_nfits_maj = 0

private

Definition at line 136 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_nfits_maj_pix

int TrackFitter::m_nfits_maj_pix = 0

private

Definition at line 138 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_nfits_maj_SCT

int TrackFitter::m_nfits_maj_SCT = 0

private

Definition at line 137 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_nfits_rec

int TrackFitter::m_nfits_rec = 0

private

Definition at line 139 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_nominalBank

const FPGATrackSimFitConstantBank* TrackFitter::m_nominalBank

private

Definition at line 124 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_norecovery_nhits

int TrackFitter::m_norecovery_nhits = -1

private

Definition at line 101 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_pmap

FPGATrackSimPlaneMap const* TrackFitter::m_pmap = nullptr

private

Definition at line 117 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_reMapVector

std::vector<int> TrackFitter::m_reMapVector

protected

Definition at line 25 of file TrigAccel/TrigCudaFitter/src/TrackFitter.h.

◆ m_require_first

bool TrackFitter::m_require_first = true

private

Definition at line 100 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_rmap

FPGATrackSimRegionMap const* TrackFitter::m_rmap = nullptr

private

Definition at line 118 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_setDoMissingHitsCheck

bool TrackFitter::m_setDoMissingHitsCheck = false

private

Definition at line 103 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

◆ m_startB

double TrackFitter::m_startB[3] {}

protected

Definition at line 23 of file TrigAccel/TrigCudaFitter/src/TrackFitter.h.

◆ m_tracks_missinghits_track

std::vector<FPGATrackSimTrack> TrackFitter::m_tracks_missinghits_track

private

Definition at line 131 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TrackFitter() [1/2]

◆ TrackFitter() [2/2]

◆ ~TrackFitter()

Member Function Documentation

◆ compute_truth()

◆ createDkfTrack()

◆ extrapolate()

◆ fit()

◆ fitTracks() [1/2]

◆ fitTracks() [2/2]

◆ getChi2DofRecoveryMax()

◆ getChi2DofRecoveryMin()

◆ getDoDeltaGPhis()

◆ getDoMajority()

◆ getDoMissingHitsCheck()

◆ getDoSecondStage()

◆ getIdealCoordFitType()

◆ getIdentifyBadHit()

◆ getMissingHitsCheckTracks()

◆ getMissingInfo()

◆ getNFits()

◆ getNFitsMajority()

◆ getNFitsMajorityPix()

◆ getNFitsMajoritySCI()

◆ getNFitsRecovery()

◆ getNorecoveryNhits()

◆ getPlaneMap()

◆ getRequireFirst()

◆ initMessaging()

◆ makeTrackCandidates()

◆ matrixInversion5x5()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ recoverTrack()

◆ resetCounters()

◆ setChi2DofRecoveryMax()

◆ setChi2DofRecoveryMin()

◆ setDoDeltaGPhis()

◆ setDoMajority()

◆ setDoMissingHitsCheck()

◆ setDoSecondStage()

◆ setIdealCoordFitType()

◆ setIdentifyBadHit()

◆ setLevel()

◆ setNorecoveryNhits()

◆ setPlaneMap()

◆ setRegionMap()

◆ setRequireFirst()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_Chi2Dof_recovery_max

◆ m_Chi2Dof_recovery_min

◆ m_do2ndStage

◆ m_do_majority

◆ m_doDeltaGPhis

◆ m_droppedLayerBanks

◆ m_endB

◆ m_guessinghits

◆ m_idbase

◆ m_IdealCoordFitType

◆ m_identify_badhit

◆ m_imsg

◆ m_lvl

◆ m_max_ncomb

◆ m_msg_tls

◆ m_nfits

◆ m_nfits_addrec

◆ m_nfits_maj

◆ m_nfits_maj_pix

◆ m_nfits_maj_SCT

◆ m_nfits_rec

◆ m_nm