#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)

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, "IdealGeoRoads", true, "Set sectors to use ideal geometry fit constants" }

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"}

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

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

◆ getNFitsMajority()

StatusCode FPGATrackSimTrackFitterTool::getNFitsMajority ( int & n )

inline

Definition at line 40 of file FPGATrackSimTrackFitterTool.h.

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

◆ getNFitsMajorityPix()

StatusCode FPGATrackSimTrackFitterTool::getNFitsMajorityPix ( int & n )

inline

Definition at line 42 of file FPGATrackSimTrackFitterTool.h.

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

◆ getNFitsMajoritySCI()

StatusCode FPGATrackSimTrackFitterTool::getNFitsMajoritySCI ( int & n )

inline

Definition at line 41 of file FPGATrackSimTrackFitterTool.h.

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

◆ getNFitsRecovery()

StatusCode FPGATrackSimTrackFitterTool::getNFitsRecovery ( int & n )

inline

Definition at line 43 of file FPGATrackSimTrackFitterTool.h.

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

◆ getTracks()

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

Definition at line 84 of file FPGATrackSimTrackFitterTool.cxx.

                                                                                                                                                {
     // elaborate the next event
     ATH_CHECK(setRoadSectors(roads));
     int status = m_tfpobj->fitTracks(roads,tracks);
     if (status != FITTRACKS_OK) return StatusCode::FAILURE;
  
     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);
  
     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_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.

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

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

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

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

◆ m_doMajority

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

private

Definition at line 50 of file FPGATrackSimTrackFitterTool.h.

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

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

◆ m_FPGATrackSimBank

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

protectedinherited

Definition at line 30 of file FPGATrackSimTrackingToolBase.h.

◆ m_FPGATrackSimMapping

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

protectedinherited

Definition at line 29 of file FPGATrackSimTrackingToolBase.h.

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

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

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

◆ m_isSecondStage

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

protectedinherited

Definition at line 39 of file FPGATrackSimTrackingToolBase.h.

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

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

◆ m_spRoadFilterTool

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

protectedinherited

Definition at line 32 of file FPGATrackSimTrackingToolBase.h.

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

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

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

Public Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FPGATrackSimTrackFitterTool()

◆ ~FPGATrackSimTrackFitterTool()

Member Function Documentation

◆ getMissingHitsCheckTracks()

◆ getNFits()

◆ getNFitsMajority()

◆ getNFitsMajorityPix()

◆ getNFitsMajoritySCI()

◆ getNFitsRecovery()

◆ getTracks()

◆ initialize()

◆ matchIdealGeoSector()

◆ setRoadSectors()

Member Data Documentation

◆ m_chi2dof_recovery_max

◆ m_chi2dof_recovery_min

◆ m_do2ndStage

◆ m_doDeltaGPhis

◆ m_doEtaPatternConsts

◆ m_doMajority

◆ m_doMissingHitsChecks

◆ m_doRegionalMapping

◆ m_FPGATrackSimBank

◆ m_FPGATrackSimMapping

◆ m_guessHits

◆ m_idealCoordFitType

◆ m_idealGeoRoads

◆ m_isSecondStage

◆ m_maxNhitsPerPlane

◆ m_noRecoveryNHits

◆ m_spRoadFilterTool

◆ m_tfpobj

◆ m_useSectors

◆ m_useSpacePoints