TrackFitter Class Reference

#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
void	setFitFromRoad (bool v)
bool	getFitFromRoad () 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.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

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.
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.
FPGATrackSimTrack	makeTrackCandidate (const FPGATrackSimRoad &road, const FPGATrackSimTrack &temp, const std::vector< int > &hit_indices)
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.
void	compute_truth (FPGATrackSimTrack &newtrk) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

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
bool	m_fitFromRoad = false
FPGATrackSimPlaneMap const *	m_pmap = nullptr
FPGATrackSimRegionMap const *	m_rmap = nullptr
std::vector< std::vector< int > >	m_comboIndices
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.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

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 515 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() << "and nhits = " << road->getNHits());
    }
 
    int sector = 0;
    if (!m_fitFromRoad) {
      // Error checking
      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);
      if (!m_fitFromRoad) temp.setFirstSectorID(road->getSector());
    }
    else{
      temp.setTrackStage(TrackStage::SECOND);
      if (!m_fitFromRoad) 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());
 
    temp.setBinIdx(road->getBinIdx());
 
    // Create a list of track candidates by taking all possible combinations of hits in road.
    std::vector<FPGATrackSimTrack> track_cands;
 
    // This may not even need to be a class member. Create the vector of possible combinations.
    std::vector<std::vector<int>> comboIndices = getComboIndices(road->getNHits_layer());
    ATH_MSG_DEBUG("There are theoretically " << comboIndices.size() << " combinations to process for this road");
    size_t nFits = 0;
    for (size_t icomb = 0; icomb < comboIndices.size(); icomb++) {
        FPGATrackSimTrack track_cand = makeTrackCandidate(*road, temp, comboIndices[icomb]);
 
        // Before we start, make sure this track candidate has not been marked as invalid
        // due to combinatorics issues with spacepoints.
        bool ok = track_cand.isValidCand();
        if (!ok) {
            continue;
        }
 
        // If the "fit from road" flag is set, then just assign track chi2 and parameters from that.
        if (!m_do2ndStage && m_fitFromRoad) {
            // Then actually do it using the road values.
            track_cand.setChi2(road->getFitChi2());
            track_cand.setChi2Phi(road->getFitChi2Phi());
            track_cand.setChi2Eta(road->getFitChi2Eta());
            track_cand.setPars(road->getFitParams());
            ATH_MSG_DEBUG("Assigned chi2 = " << track_cand.getChi2() << " and parameters from genscan tool");
            ATH_MSG_DEBUG("Set q/pt = " << track_cand.getQOverPt());
            ATH_MSG_DEBUG("Set d0 = " << track_cand.getD0());
            ATH_MSG_DEBUG("Set z0 = " << track_cand.getZ0());
            ATH_MSG_DEBUG("Set eta = " << track_cand.getEta());
            ATH_MSG_DEBUG("Set phi = " << track_cand.getPhi());
            tracks.push_back(track_cand);
            continue;
        } else {
 
        if (nMissing == 0 || m_guessinghits)
        {
            ok = m_nominalBank->linfit(sector, track_cand, 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_cand, m_do2ndStage);
        }
 
        if (!ok) {
            continue;
        }
        track_cand.setOrigChi2(track_cand.getChi2());
        if (getDoMissingHitsCheck()) {
            if (track_cand.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_cand;
                    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_cand);
 
        // Enforce m_max_ncomb here, but only for the tracks that we actually fit.
        // Let's see how often this warning fires.
        nFits += 1;
        if (nFits > (size_t)m_max_ncomb) {
            ATH_MSG_WARNING("Reached " << m_max_ncomb << " fits when processing track combinations for single road, breaking");
        }
    }
    ATH_MSG_DEBUG("Processed " << tracks.size() << " actual/valid tracks for this road");
 
    // 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)&&(!m_fitFromRoad)) {
        // 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.

{ return m_Chi2Dof_recovery_max; }

getChi2DofRecoveryMin()

float TrackFitter::getChi2DofRecoveryMin ( ) const

inline

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

{ return m_Chi2Dof_recovery_min; }

getDoDeltaGPhis()

bool TrackFitter::getDoDeltaGPhis ( ) const

inline

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

{ return m_doDeltaGPhis; }

getDoMajority()

unsigned TrackFitter::getDoMajority ( ) const

inline

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

{ return m_do_majority; }

getDoMissingHitsCheck()

bool TrackFitter::getDoMissingHitsCheck ( ) const

inline

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

{ return m_setDoMissingHitsCheck; }

getDoSecondStage()

bool TrackFitter::getDoSecondStage ( ) const

inline

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

{ return m_do2ndStage; }

getFitFromRoad()

bool TrackFitter::getFitFromRoad ( ) const

inline

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

{ return m_fitFromRoad; }

getIdealCoordFitType()

TrackCorrType TrackFitter::getIdealCoordFitType ( ) const

inline

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

{ return m_IdealCoordFitType; }

getIdentifyBadHit()

bool TrackFitter::getIdentifyBadHit ( ) const

inline

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

{ return m_identify_badhit; }

getMissingHitsCheckTracks()

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

inline

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

{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 268 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 85 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

{ return m_nfits; }

getNFitsMajority()

int TrackFitter::getNFitsMajority ( )

inline

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

{ return m_nfits_maj; }

getNFitsMajorityPix()

int TrackFitter::getNFitsMajorityPix ( )

inline

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

{ return m_nfits_maj_pix; }

getNFitsMajoritySCI()

int TrackFitter::getNFitsMajoritySCI ( )

inline

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

{ return m_nfits_maj_SCT; }

getNFitsRecovery()

int TrackFitter::getNFitsRecovery ( )

inline

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

{ return m_nfits_rec; }

getNorecoveryNhits()

int TrackFitter::getNorecoveryNhits ( ) const

inline

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

{ return m_norecovery_nhits; }

getPlaneMap()

FPGATrackSimPlaneMap const * TrackFitter::getPlaneMap ( ) const

inline

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

{ return m_pmap; }

getRequireFirst()

bool TrackFitter::getRequireFirst ( ) const

inline

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

{ 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();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

makeTrackCandidate()

FPGATrackSimTrack TrackFitter::makeTrackCandidate ( const FPGATrackSimRoad & road, const FPGATrackSimTrack & temp, const std::vector< int > & hit_indices )

private

Definition at line 392 of file TrackFitter.cxx.

{
    m_idbase += 1;
 
    FPGATrackSimTrack track_cand(temp);
 
    //get the WC hits:
    layer_bitmask_t wcbits= road.getWCLayers();
 
    //Need to set the ID and the hits size of this track
    track_cand.setTrackID(m_idbase);
    track_cand.setNLayers(m_pmap->getNLogiLayers());
 
    // If this is an idealized coordinate fit; keep references to the idealized radii.
    track_cand.setIdealRadii(m_rmap->getAvgRadii(0));
 
    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_cand.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->getSide() == 1 && layer > 0) {
                const FPGATrackSimHit inner_hit = track_cand.getFPGATrackSimHits().at(layer - 1);//avoid negative index
                if ((hit->getX() != inner_hit.getX()) || (hit->getY() != inner_hit.getY()) || (hit->getZ() != inner_hit.getZ())) {
                    track_cand.setValidCand(false);
                    break;
                }
            }
            track_cand.setFPGATrackSimHit(layer, *hit);
        }
    }
 
    return track_cand;
}

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.

This has now been done, but this function preserved for legacy support.

Definition at line 336 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();
    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 = m_comboIndices[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->getSide() == 1 && layer > 0) {
                    const FPGATrackSimHit inner_hit = track_cands[icomb].getFPGATrackSimHits().at(layer - 1);//avoid negative index
                    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 163 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 178 of file AthMessaging.h.

{ 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_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 453 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.

{ m_Chi2Dof_recovery_max = v; }

setChi2DofRecoveryMin()

void TrackFitter::setChi2DofRecoveryMin ( float v )

inline

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

{ m_Chi2Dof_recovery_min = v; }

setDoDeltaGPhis()

void TrackFitter::setDoDeltaGPhis ( bool v )

inline

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

{ m_doDeltaGPhis = v; }

setDoMajority()

void TrackFitter::setDoMajority ( unsigned int v )

inline

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

{ m_do_majority = v; }

setDoMissingHitsCheck()

void TrackFitter::setDoMissingHitsCheck ( bool v )

inline

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

{ m_setDoMissingHitsCheck = v; }

setDoSecondStage()

void TrackFitter::setDoSecondStage ( bool v )

inline

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

{ m_do2ndStage = v; }

setFitFromRoad()

void TrackFitter::setFitFromRoad ( bool v )

inline

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

{ m_fitFromRoad = v; }

setIdealCoordFitType()

void TrackFitter::setIdealCoordFitType ( TrackCorrType type )

inline

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

{m_IdealCoordFitType = type;}

setIdentifyBadHit()

void TrackFitter::setIdentifyBadHit ( bool flag )

inline

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

{ 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.

{ m_norecovery_nhits = v; }

setPlaneMap()

void TrackFitter::setPlaneMap ( FPGATrackSimPlaneMap const * map )

inline

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

{ m_pmap = map; }

setRegionMap()

void TrackFitter::setRegionMap ( FPGATrackSimRegionMap const * map )

inline

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

{ m_rmap = map; }

setRequireFirst()

void TrackFitter::setRequireFirst ( bool v )

inline

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

{ 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 110 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

m_Chi2Dof_recovery_min

float TrackFitter::m_Chi2Dof_recovery_min = 40.

private

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

m_comboIndices

std::vector<std::vector<int> > TrackFitter::m_comboIndices

private

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

m_do2ndStage

bool TrackFitter::m_do2ndStage = false

private

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

m_do_majority

unsigned TrackFitter::m_do_majority = 1

private

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

m_doDeltaGPhis

bool TrackFitter::m_doDeltaGPhis = false

private

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

m_droppedLayerBanks

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

private

Definition at line 136 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_fitFromRoad

bool TrackFitter::m_fitFromRoad = false

private

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

m_guessinghits

bool TrackFitter::m_guessinghits = true

private

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

m_idbase

int TrackFitter::m_idbase = 0

private

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

m_IdealCoordFitType

TrackCorrType TrackFitter::m_IdealCoordFitType = TrackCorrType::None

private

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

m_identify_badhit

bool TrackFitter::m_identify_badhit = false

private

Definition at line 113 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.

{ nullptr };

m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_max_ncomb

const int TrackFitter::m_max_ncomb = 10000

private

Definition at line 101 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 143 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

m_nfits_addrec

int TrackFitter::m_nfits_addrec = 0

private

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

m_nfits_maj

int TrackFitter::m_nfits_maj = 0

private

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

m_nfits_maj_pix

int TrackFitter::m_nfits_maj_pix = 0

private

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

m_nfits_maj_SCT

int TrackFitter::m_nfits_maj_SCT = 0

private

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

m_nfits_rec

int TrackFitter::m_nfits_rec = 0

private

Definition at line 147 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 132 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

m_norecovery_nhits

int TrackFitter::m_norecovery_nhits = -1

private

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

m_pmap

FPGATrackSimPlaneMap const* TrackFitter::m_pmap = nullptr

private

Definition at line 121 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 103 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

m_rmap

FPGATrackSimRegionMap const* TrackFitter::m_rmap = nullptr

private

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

m_setDoMissingHitsCheck

bool TrackFitter::m_setDoMissingHitsCheck = false

private

Definition at line 106 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 139 of file EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h.

---

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

• EFTracking/FPGATrackSim/FPGATrackSimAlgorithms/FPGATrackSimAlgorithms/TrackFitter.h
• TrigAccel/TrigCudaFitter/src/TrackFitter.h
• TrackFitter.cxx