FPGATrackSimTrackFitterTool Class Reference

#include <FPGATrackSimTrackFitterTool.h>

Inheritance diagram for FPGATrackSimTrackFitterTool:

Collaboration diagram for FPGATrackSimTrackFitterTool:

Public Member Functions
	FPGATrackSimTrackFitterTool (const std::string &, const std::string &, const IInterface *)
	~FPGATrackSimTrackFitterTool ()=default
StatusCode	initialize () override
StatusCode	getTracks (std::vector< std::shared_ptr< const FPGATrackSimRoad > > &roads, std::vector< FPGATrackSimTrack > &tracks, const FPGATrackSimTrackPars &min, const FPGATrackSimTrackPars &max)
StatusCode	getMissingHitsCheckTracks (std::vector< FPGATrackSimTrack > &tracks_guessed)
StatusCode	getNFits (int &n)
StatusCode	getNFitsMajority (int &n)
StatusCode	getNFitsMajoritySCI (int &n)
StatusCode	getNFitsMajorityPix (int &n)
StatusCode	getNFitsRecovery (int &n)
StatusCode	setRoadSectors (std::vector< std::shared_ptr< const FPGATrackSimRoad > > &roads)
void	matchIdealGeoSector (FPGATrackSimRoad &r)

Protected Attributes
ServiceHandle< IFPGATrackSimMappingSvc >	m_FPGATrackSimMapping { this,"FPGATrackSimMappingSvc","FPGATrackSimMappingSvc" }
ServiceHandle< IFPGATrackSimBankSvc >	m_FPGATrackSimBank { this,"FPGATrackSimBankSvc","FPGATrackSimBankSvc" }
ToolHandle< IFPGATrackSimRoadFilterTool >	m_spRoadFilterTool {this, "SPRoadFilterTool", "FPGATrackSimSpacepointRoadFilterTool", "Spacepoint Road Filter Tool"}
Gaudi::Property< bool >	m_doRegionalMapping { this, "RegionalMapping", false, "Use the sub-region maps to define the sector" }
Gaudi::Property< bool >	m_doEtaPatternConsts { this, "doEtaPatternConsts", false, "Whether to use the eta pattern tool for constant generation" }
Gaudi::Property< bool >	m_useSpacePoints { this, "useSpacePoints", false, "Whether we are using spacepoints." }
Gaudi::Property< bool >	m_useSectors { this, "useSectors", false, "Will reverse calculate the sector for track-fitting purposes" }
Gaudi::Property< bool >	m_idealGeoRoads { this, "IdealGeoRoads", true, "Set sectors to use ideal geometry fit constants" }
Gaudi::Property< bool >	m_isSecondStage { this, "isSecondStage", true, "Is this the second stage?" }
Gaudi::Property< bool >	m_do2ndStage {this, "Do2ndStageTrackFit", false, "Do 2nd stage track fit"}

Private Attributes
std::unique_ptr< TrackFitter >	m_tfpobj
Gaudi::Property< int >	m_chi2dof_recovery_min {this, "chi2DofRecoveryMin", 40, "min chi^2 cut for attempting recovery fits"}
Gaudi::Property< int >	m_chi2dof_recovery_max {this, "chi2DofRecoveryMax", 1e8, "max chi^2 cut for attempting recovery fits"}
Gaudi::Property< int >	m_doMajority {this, "doMajority", 1, "Do Majority fits"}
Gaudi::Property< int >	m_maxNhitsPerPlane { this, "maxHitsPerPlane", -1, "if >0, max hits per plane to consider"}
Gaudi::Property< int >	m_noRecoveryNHits { this, "nHits_noRecovery", -1, "nHits for no recovery"}
Gaudi::Property< bool >	m_guessHits { this, "GuessHits", true, "If True then we Guess hits, if False then we use separate banks and don't guess"}
Gaudi::Property< bool >	m_doDeltaGPhis { this, "DoDeltaGPhis", false, "If True will do the fit by the delta global phis method"}
Gaudi::Property< bool >	m_doMissingHitsChecks {this, "DoMissingHitsChecks", false, "If True and we guess hits, when we have 8/8 we also drop hits and guess them to compare to true positions"}
Gaudi::Property< int >	m_idealCoordFitType {this, "IdealCoordFitType", 2, "Fit type for idealized coordinates, 0 if off"}
Gaudi::Property< bool >	m_fitFromRoad {this, "fitFromRoad", true, "If set, perform the first stage fit using the genscan/inside out road-level information"}

Detailed Description

Definition at line 27 of file FPGATrackSimTrackFitterTool.h.

Constructor & Destructor Documentation

FPGATrackSimTrackFitterTool()

FPGATrackSimTrackFitterTool::FPGATrackSimTrackFitterTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 14 of file FPGATrackSimTrackFitterTool.cxx.

  : FPGATrackSimTrackingToolBase(type, name, parent)
{
}

~FPGATrackSimTrackFitterTool()

FPGATrackSimTrackFitterTool::~FPGATrackSimTrackFitterTool ( )

default

Member Function Documentation

getMissingHitsCheckTracks()

StatusCode FPGATrackSimTrackFitterTool::getMissingHitsCheckTracks

(

std::vector< FPGATrackSimTrack > &

tracks_guessed

)

Definition at line 131 of file FPGATrackSimTrackFitterTool.cxx.

{
    // only call this after we first fit the tracks!
    tracks_guessed = m_tfpobj->getMissingHitsCheckTracks();
    return StatusCode::SUCCESS;
}

getNFits()

StatusCode FPGATrackSimTrackFitterTool::getNFits ( int & n )

inline

Definition at line 39 of file FPGATrackSimTrackFitterTool.h.

{ n = m_tfpobj->getNFits();             return StatusCode::SUCCESS; }

getNFitsMajority()

StatusCode FPGATrackSimTrackFitterTool::getNFitsMajority ( int & n )

inline

Definition at line 40 of file FPGATrackSimTrackFitterTool.h.

{ n = m_tfpobj->getNFitsMajority();     return StatusCode::SUCCESS; }

getNFitsMajorityPix()

StatusCode FPGATrackSimTrackFitterTool::getNFitsMajorityPix ( int & n )

inline

Definition at line 42 of file FPGATrackSimTrackFitterTool.h.

{ n = m_tfpobj->getNFitsMajorityPix();  return StatusCode::SUCCESS; }

getNFitsMajoritySCI()

StatusCode FPGATrackSimTrackFitterTool::getNFitsMajoritySCI ( int & n )

inline

Definition at line 41 of file FPGATrackSimTrackFitterTool.h.

{ n = m_tfpobj->getNFitsMajoritySCI();  return StatusCode::SUCCESS; }

getNFitsRecovery()

StatusCode FPGATrackSimTrackFitterTool::getNFitsRecovery ( int & n )

inline

Definition at line 43 of file FPGATrackSimTrackFitterTool.h.

{ n = m_tfpobj->getNFitsRecovery();     return StatusCode::SUCCESS; }

getTracks()

StatusCode FPGATrackSimTrackFitterTool::getTracks	(	std::vector< std::shared_ptr< const FPGATrackSimRoad > > &	roads,
		std::vector< FPGATrackSimTrack > &	tracks,
		const FPGATrackSimTrackPars &	min,
		const FPGATrackSimTrackPars &	max )

Definition at line 86 of file FPGATrackSimTrackFitterTool.cxx.

                                                                                                                                                                                                                   {
    // elaborate the next event
  if (!m_fitFromRoad) ATH_CHECK(setRoadSectors(roads)); // we do not need to set sectors in this case
    int status = m_tfpobj->fitTracks(roads,tracks);
    if (status != FITTRACKS_OK) return StatusCode::FAILURE;
 
    // Make sure none of our track parameters go outside the appropriate boundary
    for (auto track : tracks) {
 
      double qopt = track.getQOverPt();
      double eta = track.getEta();
      double phi = track.getPhi();
      double d0 = track.getD0();
      double z0 = track.getZ0();
      if (qopt < min[FPGATrackSimTrackPars::IHIP]) qopt = min[FPGATrackSimTrackPars::IHIP];
      if (qopt > max[FPGATrackSimTrackPars::IHIP]) qopt = max[FPGATrackSimTrackPars::IHIP];
      if (eta < min[FPGATrackSimTrackPars::IETA]) eta = min[FPGATrackSimTrackPars::IETA];
      if (eta > max[FPGATrackSimTrackPars::IETA]) eta = max[FPGATrackSimTrackPars::IETA];
      if (phi < min[FPGATrackSimTrackPars::IPHI]) phi = min[FPGATrackSimTrackPars::IPHI];
      if (phi > max[FPGATrackSimTrackPars::IPHI]) phi = max[FPGATrackSimTrackPars::IPHI];
      if (d0 < min[FPGATrackSimTrackPars::ID0]) d0 = min[FPGATrackSimTrackPars::ID0];
      if (d0 > max[FPGATrackSimTrackPars::ID0]) d0 = max[FPGATrackSimTrackPars::ID0];
      if (z0 < min[FPGATrackSimTrackPars::IZ0]) z0 = min[FPGATrackSimTrackPars::IZ0];
      if (z0 > max[FPGATrackSimTrackPars::IZ0]) z0 = max[FPGATrackSimTrackPars::IZ0];
      
      track.setQOverPt(qopt);
      track.setEta(eta);
      track.setPhi(phi);
      track.setD0(d0);
      track.setZ0(z0);           
    }
    
    if (msgLvl(MSG::DEBUG))
    {
        ATH_MSG_DEBUG("getTracks() returning " << tracks.size() << " tracks:");
        for (auto & t : tracks)
            ATH_MSG_DEBUG("\tchi2 = " << t.getChi2() << " and phi = " << t.getPhi()
                    << " and eta = " << t.getEta() << " and d0 = " << t.getD0()
                    << " and z0 = " << t.getZ0() << "and pt = " << t.getPt());
    }
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode FPGATrackSimTrackFitterTool::initialize ( )

override

Definition at line 23 of file FPGATrackSimTrackFitterTool.cxx.

{
    ATH_MSG_DEBUG("FPGATrackSimTrackFitterTool::initialize()");
 
    ATH_CHECK(m_FPGATrackSimMapping.retrieve());
    ATH_CHECK(m_FPGATrackSimBank.retrieve());
    if (m_useSpacePoints) ATH_CHECK(m_spRoadFilterTool.retrieve(EnableTool{m_spRoadFilterTool}));
 
    const FPGATrackSimFitConstantBank* nominalbank;
    std::vector<const FPGATrackSimFitConstantBank*> bankvec;
    if(!m_do2ndStage){
      nominalbank = m_FPGATrackSimBank->FitConstantBank_1st();
      if (!m_guessHits) {
        for (unsigned int iplane = 0; iplane < m_FPGATrackSimMapping->PlaneMap_1st(0)->getNLogiLayers(); iplane++) {
      const FPGATrackSimFitConstantBank* bank = m_FPGATrackSimBank->FitConstantBank_1st(iplane);
      bankvec.push_back(bank);
        }
      }
    }
    else {
      nominalbank = m_FPGATrackSimBank->FitConstantBank_2nd();
      if (!m_guessHits) {
        for (unsigned int iplane = 0; iplane < m_FPGATrackSimMapping->PlaneMap_2nd(0)->getNLogiLayers(); iplane++) {
          const FPGATrackSimFitConstantBank* bank = m_FPGATrackSimBank->FitConstantBank_2nd(iplane);
          bankvec.push_back(bank);
        }
      }
    }
 
    MsgStream m(msgSvc(), "TrackFitter");
    m.setLevel(msg().level());
    m_tfpobj = std::unique_ptr<TrackFitter>(new TrackFitter(nominalbank, bankvec, m_guessHits));
 
    if(!m_do2ndStage) {
      m_tfpobj->setPlaneMap(m_FPGATrackSimMapping->PlaneMap_1st(0));
      m_tfpobj->setRegionMap(m_FPGATrackSimMapping->RegionMap_1st());
    } else {
      m_tfpobj->setPlaneMap(m_FPGATrackSimMapping->PlaneMap_2nd(0));
      m_tfpobj->setRegionMap(m_FPGATrackSimMapping->RegionMap_2nd());
    }
 
    // set parameter object to TrackFitter
    m_tfpobj->setChi2DofRecoveryMin(m_chi2dof_recovery_min);
    m_tfpobj->setChi2DofRecoveryMax(m_chi2dof_recovery_max);
 
    m_tfpobj->setDoMajority(m_doMajority);
 
    m_tfpobj->setRequireFirst(0);
    m_tfpobj->setDoSecondStage(m_do2ndStage);
 
    m_tfpobj->setNorecoveryNhits(m_noRecoveryNHits);
 
    m_tfpobj->setFitFromRoad(m_fitFromRoad);
 
    if (!m_guessHits && m_doMissingHitsChecks) ATH_MSG_WARNING("We can't do missing hits check if we don't guess hits");
    m_tfpobj->setDoMissingHitsCheck(m_doMissingHitsChecks);
    m_tfpobj->setIdealCoordFitType(static_cast<TrackCorrType>(m_idealCoordFitType.value()));
    m_tfpobj->setDoDeltaGPhis(m_doDeltaGPhis);
 
    return StatusCode::SUCCESS;
}

matchIdealGeoSector()

void FPGATrackSimTrackingToolBase::matchIdealGeoSector ( FPGATrackSimRoad & r )

inherited

Definition at line 36 of file FPGATrackSimTrackingToolBase.cxx.

{
    // We now look up the binning information in the sector bank.
    const FPGATrackSimSectorBank* sectorbank = nullptr;
    if(! m_do2ndStage)
      sectorbank = m_FPGATrackSimBank->SectorBank_1st();
    else
      sectorbank = m_FPGATrackSimBank->SectorBank_2nd();
 
    // Look up q/pt (or |q/pt|) from the Hough road, convert to MeV.
    double qoverpt = r.getY()*0.001;
    if (sectorbank->isAbsQOverPtBinning()) {
       qoverpt = std::abs(qoverpt);
    }
 
    // Retrieve the bin boundaries from the sector bank; map this onto them.
    const std::vector<double> &qoverpt_bins = sectorbank->getQOverPtBins();
    auto bounds = std::equal_range(qoverpt_bins.begin(), qoverpt_bins.end(), qoverpt);
 
    // estimate sectorbin
    int sectorbin = fpgatracksim::QPT_SECTOR_OFFSET * (bounds.first - qoverpt_bins.begin() - 1);
    sectorbin = std::clamp(sectorbin, 0, 10 * static_cast<int>(qoverpt_bins.size() - 2));
    if (m_do2ndStage) sectorbin = 0;
 
    if (m_doRegionalMapping){
      int subregion = r.getSubRegion();
      sectorbin += subregion*fpgatracksim::SUBREGION_SECTOR_OFFSET;
    }
 
    std::vector<module_t> modules(r.getNLayers(), -1);
    layer_bitmask_t wc_layers = r.getWCLayers();
    for (unsigned int il = 0; il < r.getNLayers(); il++) {
        if (r.getNHits_layer()[il] == 0) {
 
            // set corresponding bit to 1 in case of wc in the current layer
            wc_layers |= (0x1 << il);
 
            std::unique_ptr<FPGATrackSimHit> wcHit = std::make_unique<FPGATrackSimHit>();
            wcHit->setHitType(HitType::wildcard);
            wcHit->setLayer(il);
            if(! m_do2ndStage)
              wcHit->setDetType(m_FPGATrackSimMapping->PlaneMap_1st(0)->getDetType(il));
            else
              wcHit->setDetType(m_FPGATrackSimMapping->PlaneMap_2nd(0)->getDetType(il));
 
            // Now store wc hit in a "std::vector<std::shared_ptr<const FPGATrackSimHit>>" format.
            // We can probably avoid initializing an intermediate variable wcHits as we used to do
            r.setHits(il,{std::move(wcHit)});
        }
        else {
            modules[il]= sectorbin;
        }
    }
    r.setWCLayers(wc_layers);
 
 
    // If we are using eta patterns. We need to first run the roads through the road filter.
    // Then the filter will be responsible for setting the actual sector.
    // As a hack, we can store the sector bin ID in the road for now.
    // This is fragile! If we want to store a different ID for each layer, it will break.
 
    // Similarly, we do the same thing for spacepoints. this probably means we can't combine the two.
    // maybe better to store the module array instead of just a number?
    
    r.setSectorBin(sectorbin);
    if (!m_doEtaPatternConsts && !m_useSpacePoints) {
        r.setSector(sectorbank->findSector(modules));
    }
}

setRoadSectors()

StatusCode FPGATrackSimTrackingToolBase::setRoadSectors ( std::vector< std::shared_ptr< const FPGATrackSimRoad > > & roads )

inherited

Definition at line 11 of file FPGATrackSimTrackingToolBase.cxx.

{
  for (auto& road: roads)
  {
    std::shared_ptr<FPGATrackSimRoad> nonConstRoad = std::const_pointer_cast<FPGATrackSimRoad>(road);
    if (m_useSectors) {
      if(! m_do2ndStage)
        nonConstRoad->setSector(m_FPGATrackSimBank->SectorBank_1st()->findSector(nonConstRoad->getAllHits()));
      else
        nonConstRoad->setSector(m_FPGATrackSimBank->SectorBank_2nd()->findSector(nonConstRoad->getAllHits()));
    }
    else if (m_idealGeoRoads) matchIdealGeoSector(*nonConstRoad);
  }
  // Spacepoint road filter tool. Needed when fitting to spacepoints.
  if (m_useSpacePoints)
  {
    std::vector<std::shared_ptr<const FPGATrackSimRoad>> postfilter_roads;
    ATH_CHECK(m_spRoadFilterTool->filterRoads(roads, postfilter_roads));
    roads = std::move(postfilter_roads);
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_chi2dof_recovery_max

Gaudi::Property<int> FPGATrackSimTrackFitterTool::m_chi2dof_recovery_max {this, "chi2DofRecoveryMax", 1e8, "max chi^2 cut for attempting recovery fits"}

private

Definition at line 49 of file FPGATrackSimTrackFitterTool.h.

{this, "chi2DofRecoveryMax", 1e8, "max chi^2 cut for attempting recovery fits"};

m_chi2dof_recovery_min

Gaudi::Property<int> FPGATrackSimTrackFitterTool::m_chi2dof_recovery_min {this, "chi2DofRecoveryMin", 40, "min chi^2 cut for attempting recovery fits"}

private

Definition at line 48 of file FPGATrackSimTrackFitterTool.h.

{this, "chi2DofRecoveryMin", 40, "min chi^2 cut for attempting recovery fits"};

m_do2ndStage

Gaudi::Property<bool> FPGATrackSimTrackingToolBase::m_do2ndStage {this, "Do2ndStageTrackFit", false, "Do 2nd stage track fit"}

protectedinherited

Definition at line 40 of file FPGATrackSimTrackingToolBase.h.

{this, "Do2ndStageTrackFit", false, "Do 2nd stage track fit"};

m_doDeltaGPhis

Gaudi::Property<bool> FPGATrackSimTrackFitterTool::m_doDeltaGPhis { this, "DoDeltaGPhis", false, "If True will do the fit by the delta global phis method"}

private

Definition at line 54 of file FPGATrackSimTrackFitterTool.h.

{ this, "DoDeltaGPhis", false, "If True will do the fit by the delta global phis method"};

m_doEtaPatternConsts

Gaudi::Property<bool> FPGATrackSimTrackingToolBase::m_doEtaPatternConsts { this, "doEtaPatternConsts", false, "Whether to use the eta pattern tool for constant generation" }

protectedinherited

Definition at line 35 of file FPGATrackSimTrackingToolBase.h.

{ this, "doEtaPatternConsts", false, "Whether to use the eta pattern tool for constant generation" };

m_doMajority

Gaudi::Property<int> FPGATrackSimTrackFitterTool::m_doMajority {this, "doMajority", 1, "Do Majority fits"}

private

Definition at line 50 of file FPGATrackSimTrackFitterTool.h.

{this, "doMajority", 1, "Do Majority fits"};

m_doMissingHitsChecks

Gaudi::Property<bool> FPGATrackSimTrackFitterTool::m_doMissingHitsChecks {this, "DoMissingHitsChecks", false, "If True and we guess hits, when we have 8/8 we also drop hits and guess them to compare to true positions"}

private

Definition at line 55 of file FPGATrackSimTrackFitterTool.h.

{this, "DoMissingHitsChecks", false, "If True and we guess hits, when we have 8/8 we also drop hits and guess them to compare to true positions"};

m_doRegionalMapping

Gaudi::Property<bool> FPGATrackSimTrackingToolBase::m_doRegionalMapping { this, "RegionalMapping", false, "Use the sub-region maps to define the sector" }

protectedinherited

Definition at line 34 of file FPGATrackSimTrackingToolBase.h.

{ this, "RegionalMapping", false, "Use the sub-region maps to define the sector" };

m_fitFromRoad

Gaudi::Property<bool> FPGATrackSimTrackFitterTool::m_fitFromRoad {this, "fitFromRoad", true, "If set, perform the first stage fit using the genscan/inside out road-level information"}

private

Definition at line 57 of file FPGATrackSimTrackFitterTool.h.

{this, "fitFromRoad", true, "If set, perform the first stage fit using the genscan/inside out road-level information"};

m_FPGATrackSimBank

ServiceHandle<IFPGATrackSimBankSvc> FPGATrackSimTrackingToolBase::m_FPGATrackSimBank { this,"FPGATrackSimBankSvc","FPGATrackSimBankSvc" }

protectedinherited

Definition at line 30 of file FPGATrackSimTrackingToolBase.h.

{ this,"FPGATrackSimBankSvc","FPGATrackSimBankSvc" };

m_FPGATrackSimMapping

ServiceHandle<IFPGATrackSimMappingSvc> FPGATrackSimTrackingToolBase::m_FPGATrackSimMapping { this,"FPGATrackSimMappingSvc","FPGATrackSimMappingSvc" }

protectedinherited

Definition at line 29 of file FPGATrackSimTrackingToolBase.h.

{ this,"FPGATrackSimMappingSvc","FPGATrackSimMappingSvc" };

m_guessHits

Gaudi::Property<bool> FPGATrackSimTrackFitterTool::m_guessHits { this, "GuessHits", true, "If True then we Guess hits, if False then we use separate banks and don't guess"}

private

Definition at line 53 of file FPGATrackSimTrackFitterTool.h.

{ this, "GuessHits", true,  "If True then we Guess hits, if False then we use separate banks and don't guess"};

m_idealCoordFitType

Gaudi::Property<int> FPGATrackSimTrackFitterTool::m_idealCoordFitType {this, "IdealCoordFitType", 2, "Fit type for idealized coordinates, 0 if off"}

private

Definition at line 56 of file FPGATrackSimTrackFitterTool.h.

{this, "IdealCoordFitType", 2, "Fit type for idealized coordinates, 0 if off"};

m_idealGeoRoads

Gaudi::Property<bool> FPGATrackSimTrackingToolBase::m_idealGeoRoads { this, "IdealGeoRoads", true, "Set sectors to use ideal geometry fit constants" }

protectedinherited

Definition at line 38 of file FPGATrackSimTrackingToolBase.h.

{ this, "IdealGeoRoads", true, "Set sectors to use ideal geometry fit constants" };

m_isSecondStage

Gaudi::Property<bool> FPGATrackSimTrackingToolBase::m_isSecondStage { this, "isSecondStage", true, "Is this the second stage?" }

protectedinherited

Definition at line 39 of file FPGATrackSimTrackingToolBase.h.

{ this, "isSecondStage", true, "Is this the second stage?" };

m_maxNhitsPerPlane

Gaudi::Property<int> FPGATrackSimTrackFitterTool::m_maxNhitsPerPlane { this, "maxHitsPerPlane", -1, "if >0, max hits per plane to consider"}

private

Definition at line 51 of file FPGATrackSimTrackFitterTool.h.

{ this, "maxHitsPerPlane", -1, "if >0, max hits per plane to consider"};

m_noRecoveryNHits

Gaudi::Property<int> FPGATrackSimTrackFitterTool::m_noRecoveryNHits { this, "nHits_noRecovery", -1, "nHits for no recovery"}

private

Definition at line 52 of file FPGATrackSimTrackFitterTool.h.

{ this, "nHits_noRecovery", -1, "nHits for no recovery"};

m_spRoadFilterTool

ToolHandle<IFPGATrackSimRoadFilterTool> FPGATrackSimTrackingToolBase::m_spRoadFilterTool {this, "SPRoadFilterTool", "FPGATrackSimSpacepointRoadFilterTool", "Spacepoint Road Filter Tool"}

protectedinherited

Definition at line 32 of file FPGATrackSimTrackingToolBase.h.

{this, "SPRoadFilterTool", "FPGATrackSimSpacepointRoadFilterTool", "Spacepoint Road Filter Tool"};

m_tfpobj

std::unique_ptr<TrackFitter> FPGATrackSimTrackFitterTool::m_tfpobj

private

Definition at line 46 of file FPGATrackSimTrackFitterTool.h.

m_useSectors

Gaudi::Property<bool> FPGATrackSimTrackingToolBase::m_useSectors { this, "useSectors", false, "Will reverse calculate the sector for track-fitting purposes" }

protectedinherited

Definition at line 37 of file FPGATrackSimTrackingToolBase.h.

{ this, "useSectors", false, "Will reverse calculate the sector for track-fitting purposes" };

m_useSpacePoints

Gaudi::Property<bool> FPGATrackSimTrackingToolBase::m_useSpacePoints { this, "useSpacePoints", false, "Whether we are using spacepoints." }

protectedinherited

Definition at line 36 of file FPGATrackSimTrackingToolBase.h.

{ this, "useSpacePoints", false, "Whether we are using spacepoints." };

---

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

• FPGATrackSimTrackFitterTool.h
• FPGATrackSimTrackFitterTool.cxx