#include <FPGATrackSimHough1DShiftTool.h>

Inheritance diagram for FPGATrackSimHough1DShiftTool:

Collaboration diagram for FPGATrackSimHough1DShiftTool:

Public Member Functions
	FPGATrackSimHough1DShiftTool (const std::string &, const std::string &, const IInterface *)

virtual StatusCode	initialize () override

virtual StatusCode	finalize () override

virtual StatusCode	getRoads (const std::vector< std::shared_ptr< const FPGATrackSimHit >> &hits, std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads) override

Private Member Functions
void	calculateShifts ()

float	getPtFromShiftDiff (int shift) const

void	readShifts (std::string const &filepath)

std::vector< boost::dynamic_bitset<> >	makeHitMasks (const std::vector< std::shared_ptr< const FPGATrackSimHit >> &hits)

FPGATrackSimRoad	makeRoad (const std::vector< std::shared_ptr< const FPGATrackSimHit >> &hits, int bin_track, size_t iShift)

void	matchIdealGeoSector (FPGATrackSimRoad &r) const

bool	passThreshold (std::vector< boost::dynamic_bitset<>> &binHits, int bin) const

void	printHitMasks (std::vector< boost::dynamic_bitset<>> const &hitMasks) const

void	drawHitMasks (std::vector< boost::dynamic_bitset<>> const &hitMasks, std::string const &name)

void	drawHitMasks (std::vector< boost::dynamic_bitset<>> const &hitMasks, std::string const &name, std::vector< int > const &shifts)

void	printShifts () const

std::pair< int, int >	getBins (const std::shared_ptr< const FPGATrackSimHit > &hit) const

float	phitrkDiff (float r1, float phi1, float r2, float phi2) const

std::pair< float, bool >	phitrk (int bin, std::vector< int > const &shifts) const

float	qPt (float r, float deltaPhi) const

float	deltaPhi (float r, float qPt) const

void	calculated0Shifts ()

std::vector< int >	applyVariation (const std::vector< int > &base, const std::vector< int > &var, int sign) const

void	calculateDropable ()

std::vector< int >	shiftWithDrop (std::vector< int > &shift, unsigned droplayer) const

Private Attributes
ServiceHandle< IFPGATrackSimEventSelectionSvc >	m_EvtSel {this, "FPGATrackSimEventSelectionSvc", "FPGATrackSimEventSelectionSvc"}

ServiceHandle< IFPGATrackSimBankSvc >	m_FPGATrackSimBankSvc {this, "FPGATrackSimBankSvc", "FPGATrackSimBankSvc"}

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

Gaudi::Property< bool >	m_traceHits { this, "traceHits", true, "Trace each hit that goes in a bin. Disabling this will save memory/time since each bin doesn't have to store all its hits but the roads created won't have hits from convolution, etc."}

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

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

Gaudi::Property< bool >	m_drawHitMasks { this, "drawHitMasks", false, "Draws hit masks if true"}

Gaudi::Property< int >	m_subRegion { this, "subRegion", 0, "Sub region of this transform, or -1 for full region" }

Gaudi::Property< float >	m_phiMin { this, "phiMin", 0, "Minimum phi of transform" }

Gaudi::Property< float >	m_phiMax { this, "phiMax", 0, "Maximum phi of transform" }

Gaudi::Property< float >	m_qptMin { this, "qptMin", 0, "Minimum q/pT of transform" }

Gaudi::Property< float >	m_qptMax { this, "qptMax", 0, "Maximum q/pT of transform" }

Gaudi::Property< unsigned >	m_phiBins { this, "nBins", 0, "Number of phi bins used by transform." }

Gaudi::Property< unsigned >	m_threshold { this, "threshold", 0, "Minimum number of layers hit to accept as a road (inclusive)" }

Gaudi::Property< unsigned >	m_iterStep { this, "iterStep", 0, "Instead of iterating over steps in pT, we iterate over iterStep-bin shifts in iterLayer" }

Gaudi::Property< unsigned >	m_iterLayer { this, "iterLayer", 0, "Instead of iterating over steps in pT, we iterate over iterStep-bin shifts in iterLayer" }

Gaudi::Property< bool >	m_useDiff { this, "useDiff", false, "Use the diff of inner and outer layer" }

Gaudi::Property< bool >	m_variableExtend { this, "variableExtend", false, "Do variable extension based off of hit delta R" }

Gaudi::Property< bool >	m_phiRangeCut {this, "phiRangeCut", false, "Require tracks to be in phi range to avoid counting minbias roads for larger region" }

Gaudi::Property< float >	m_d0spread {this, "d0spread", -1.0, "Make patterns with a d0spread as given, negative value turns it off" }

Gaudi::Property< std::vector< float > >	m_hitExtendProperty {this, "hitExtend", {}, "Number of adjacent bins that a hit triggers" }

Gaudi::Property< std::string >	m_bitShift_path { this, "bitShifts", "", "Instead of calculating bit shifts, input a list of shifts via a text file" }

Gaudi::Property< bool >	m_applyDropable { this, "applyDropable", false, "Enable logic that prevents redundant patterns with dropped hits" }

Gaudi::Property< int >	m_neighborWindow { this, "neighborWindow", 0, "Supress if neighbors have higher number of hit layers" }

Gaudi::Property< unsigned >	m_historyWindow {this, "historyWindow", 0, "Suppress if previous N bit shifts have neighbors with higher nubmer of hit layers" }

Gaudi::Property< bool >	m_fieldCorrection {this, "fieldCorrection", true, "Apply corrections to hough equation due to field nonuniformity" }

Gaudi::Property< float >	m_enhanceHighPt {this, "enhanceHighPt", -1.0, "if positive, double number of patterns for region with qpT below value" }

std::vector< float >	m_hitExtend

std::vector< float >	m_r

unsigned	m_nLayers

float	m_phiStep

std::vector< double >	m_bins

FPGATrackSimTrackPars	m_regionMin

FPGATrackSimTrackPars	m_regionMax

std::vector< std::vector< int > >	m_shifts

std::vector< boost::dynamic_bitset<> >	m_dropable

std::vector< float >	m_qpt

std::vector< std::vector< float > >	m_phivals

std::vector< std::vector< int > >	m_d0shifts

std::vector< unsigned >	m_currentcounts

std::deque< std::vector< unsigned > >	m_vetolist

std::vector< FPGATrackSimRoad >	m_roads

unsigned	m_event = 0

std::string	m_name

TFile	m_monitorFile

Detailed Description

Definition at line 84 of file FPGATrackSimHough1DShiftTool.h.

Constructor & Destructor Documentation

◆ FPGATrackSimHough1DShiftTool()

FPGATrackSimHough1DShiftTool::FPGATrackSimHough1DShiftTool	(	const std::string &	algname,
		const std::string &	name,
		const IInterface *	ifc
	)

Definition at line 39 of file FPGATrackSimHough1DShiftTool.cxx.

                                                                                                                                  :
   base_class(algname, name, ifc)
 {
   declareInterface<IFPGATrackSimRoadFinderTool>(this);
 }

Member Function Documentation

◆ applyVariation()

std::vector< int > FPGATrackSimHough1DShiftTool::applyVariation	(	const std::vector< int > &	base,
		const std::vector< int > &	var,
		int	sign
	)		const

private

Definition at line 742 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     std::vector<int> retv;
  
     if (base.size()!=var.size()) {
       ATH_MSG_ERROR("Base and Var lengths must match " << base.size() << " " << var.size() );
     }
  
     for (unsigned i = 0; i < base.size(); i++) {
       retv.push_back(base[i]+sign*var[i]);
     }
     return retv;
 }

◆ calculated0Shifts()

void FPGATrackSimHough1DShiftTool::calculated0Shifts ( )

private

Definition at line 723 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     int steps=1;
     while (true) {
       float d0step = steps*m_phiStep*m_r[0];
       ATH_MSG_DEBUG("d0step = " << d0step);
       std::vector<int> d0shift;
       for (unsigned lyr = 0; lyr < m_nLayers; lyr++) {
          float phi_for_d0step = d0step/m_r[lyr];
          int shift = static_cast<int>(round(phi_for_d0step/ m_phiStep));
          d0shift.push_back(shift);
       }
       m_d0shifts.push_back(d0shift);
       if (d0step>m_d0spread) break;
       ++steps;
     }
     ATH_MSG_DEBUG("d0 Shifts Found = " << m_d0shifts.size());
 }

◆ calculateDropable()

void FPGATrackSimHough1DShiftTool::calculateDropable ( )

private

Definition at line 765 of file FPGATrackSimHough1DShiftTool.cxx.

 {
  
   // one set per layer with shift set
   std::vector< std::set< std::vector<int> > > reducedShifts(m_nLayers);
  
   m_dropable.resize(m_shifts.size());
  
   for (size_t iShift = 0; iShift < m_shifts.size(); iShift++)
   {
     boost::dynamic_bitset<> drops(m_nLayers);
     for (unsigned droplayer =0; droplayer < m_nLayers; droplayer++) {
        if (reducedShifts[droplayer].insert(shiftWithDrop(m_shifts[iShift],droplayer)).second) {
           // true if the is a new shift in the set
           drops.set(droplayer);
        }
     }
     
     m_dropable[iShift]=drops;
  
   }
  
 }

◆ calculateShifts()

void FPGATrackSimHough1DShiftTool::calculateShifts ( )

private

Definition at line 124 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     // Calculated d0shift if selected
     if (m_d0spread>0) calculated0Shifts();
  
  
     // Iterate over a steps of m_iterStep bin shift in m_iterLayer
     for (int sign = -1; sign<2; sign+=2) {
  
     // start at highest pT
     float iterShift = (sign>0) ? 0.0 : -1.0; // don't double count zero
  
     while (true)
     {
         float qpt = qPt(m_r[m_iterLayer], m_phiStep * iterShift);
         if (abs(qpt)>std::max(abs(m_qptMin),abs(m_qptMax))) break;
  
         if ((qpt <= m_qptMax ) && (qpt >= m_qptMin )) {
  
         std::vector<int> shifts; // Fill both +iterShift and -iterShift here
         for (unsigned i = 0; i < m_nLayers; i++)
         {
             float dPhi = deltaPhi(m_r[i], qpt);
             if (m_useDiff){
             dPhi -= deltaPhi(m_r[0], qpt);
             }
  
             int shift = static_cast<int>(round(dPhi / m_phiStep));
             if (shift >= static_cast<int>(m_phiBins) || shift <= -(static_cast<int>(m_phiBins))) return;
             shifts.push_back(shift);
         }
  
         // if thre are d0shifts, apply them
         for (const std::vector<int>& d0shift: m_d0shifts){
             m_shifts.push_back(applyVariation(shifts,d0shift,1));
             m_shifts.push_back(applyVariation(shifts,d0shift,-1));
         }
  
         m_qpt.push_back(qpt);
         m_shifts.push_back(shifts);
  
         }
  
         // smaller steps if in "enhanceHighPt" range
         iterShift += ((std::abs(qpt)>m_enhanceHighPt) ?  sign*float(m_iterStep): sign*float(m_iterStep)/2.0) ;
     }
     ATH_MSG_INFO("Ending shift, qpt("<< m_qptMin << ", " << m_qptMax <<") sign:" <<  sign << " shift:" << iterShift);
  
  
     // figure out which patterns are the same after dropping a hit
     calculateDropable();
     }
  
 }

◆ deltaPhi()

float FPGATrackSimHough1DShiftTool::deltaPhi	(	float	r,
		float	qPt
	)		const

private

Definition at line 618 of file FPGATrackSimHough1DShiftTool.cxx.

 {
    float dPhi = std::asin(fpgatracksim::A * r * qPt);
     if (m_fieldCorrection) dPhi += fieldCorrection(m_EvtSel->getRegionID(), qPt, r);
     return dPhi;
 }

◆ drawHitMasks() [1/2]

void FPGATrackSimHough1DShiftTool::drawHitMasks	(	std::vector< boost::dynamic_bitset<>> const &	hitMasks,
		std::string const &	name
	)

private

Definition at line 682 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     m_monitorFile.cd();
  
     TH2F h(name.c_str(), "Hough 1D Shift;phi;layer",
             m_phiBins, m_phiMin, m_phiMax,
             m_nLayers, 0, m_nLayers
     );
  
     for (size_t layer = 0; layer < m_nLayers; layer++)
         for (size_t i = 0; i < m_phiBins; i++)
             h.SetBinContent(i+1, layer+1, hitMasks[layer][i]); // +1 since root bins are 1-indexed
  
     h.Write();
 }

◆ drawHitMasks() [2/2]

void FPGATrackSimHough1DShiftTool::drawHitMasks	(	std::vector< boost::dynamic_bitset<>> const &	hitMasks,
		std::string const &	name,
		std::vector< int > const &	shifts
	)

private

Definition at line 698 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     std::vector<boost::dynamic_bitset<>> shiftedMasks;
     for (size_t layer = 0; layer < m_nLayers; layer++)
         shiftedMasks.push_back(lshift(hitMasks[layer], shifts[layer]));
  
     drawHitMasks(shiftedMasks, name);
 }

◆ finalize()

StatusCode FPGATrackSimHough1DShiftTool::finalize ( )

overridevirtual

Definition at line 307 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     return StatusCode::SUCCESS;
 }

◆ getBins()

std::pair< int, int > FPGATrackSimHough1DShiftTool::getBins ( const std::shared_ptr< const FPGATrackSimHit > & hit ) const

private

Definition at line 564 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     float phi = hit->getGPhi();
     float bin_extend = m_hitExtend[hit->getLayer()];
     float center = (phi - m_phiMin) / m_phiStep;
  
     if (m_variableExtend){
       float r = hit->getR();
       float dphimax = deltaPhi(r,m_qptMax);
       float maxshift = +1*((std::sin(dphimax)*(r-m_r[hit->getLayer()]))/r)/m_phiStep;
       float dphimin = deltaPhi(r,m_qptMin);
       float minshift = +1*((std::sin(dphimin)*(r-m_r[hit->getLayer()]))/r)/m_phiStep;
  
       center += (maxshift+minshift)/2.0;
       bin_extend += std::abs((maxshift-minshift)/2.0);
  
     }
  
     int low = std::max(static_cast<int>(center - bin_extend),0);
     int high = std::min(static_cast<int>(center + bin_extend),static_cast<int>(m_phiBins-1));
     return { low, high };
 }

◆ getPtFromShiftDiff()

float FPGATrackSimHough1DShiftTool::getPtFromShiftDiff ( int shift ) const

private

Definition at line 556 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     if (m_iterLayer == 0u) ATH_MSG_FATAL("getPtFromShiftDiff() iterLayer can't be 0");
     return (shift * m_phiStep / fpgatracksim::A) / (m_r[m_iterLayer] - m_r[0]);
 }

◆ getRoads()

StatusCode FPGATrackSimHough1DShiftTool::getRoads	(	const std::vector< std::shared_ptr< const FPGATrackSimHit >> &	hits,
		std::vector< std::shared_ptr< const FPGATrackSimRoad >> &	roads
	)

overridevirtual

Definition at line 316 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     
     roads.clear();
     m_roads.clear();
  
     ATH_MSG_DEBUG("Input Hits Size:" << hits.size() << "\n");
  
     // Get hit masks
     std::vector<boost::dynamic_bitset<>> hitMasks(makeHitMasks(hits));
     if (m_drawHitMasks) drawHitMasks(hitMasks, m_name + "_e" + std::to_string(m_event));
  
     // Iterate over shifts
     for (size_t iShift = 0; iShift < m_shifts.size(); iShift++)
     {
           // Track hit layers in each bin
         std::vector<boost::dynamic_bitset<>> binHits(m_phiBins, boost::dynamic_bitset<>(m_nLayers));
  
  
         // Add the counts
         for (unsigned i = 0; i < m_nLayers; i++)
             updateBinHits(binHits, i, lshift(hitMasks[i], m_shifts[iShift][i]));
  
         // Check the threshold
         for (unsigned bin = 0; bin < m_phiBins; bin++)
         {
         // First check we're not missing hits in not allowed layers
         if (m_applyDropable && !m_dropable.empty() && (~(binHits[bin] | m_dropable[iShift])).any()) continue;
  
         m_currentcounts[bin]=binHits[bin].count();
  
             if (passThreshold(binHits,bin))
             {
           FPGATrackSimRoad r = makeRoad(hits, bin, iShift);
  
           if (m_phiRangeCut && (r.getX() > m_regionMax.phi || r.getX() < m_regionMin.phi)) continue;
  
           m_roads.push_back(r);
  
           ATH_MSG_DEBUG("New Road: "<< layersHit(r) <<" lyrs,  " << r.getNHits() << " hits :"
                << to_string(r.getNHits_layer()) << " reg=" <<  r.getSubRegion()
                << " bin=" << bin << " shift=" << iShift << " phi=" << r.getX() << " pti=" << r.getY() << " " << m_qpt[iShift]);
  
  
             }
  
         }
  
     // Add/Remove history
     m_vetolist.push_front(m_currentcounts);
     if (m_vetolist.size() > m_historyWindow) {
         m_vetolist.pop_back();
     }
     }
  
     roads.reserve(m_roads.size());
     for (FPGATrackSimRoad & r : m_roads) roads.emplace_back(std::make_shared<const FPGATrackSimRoad>(r));
  
     if (roads.size()==0 && m_drawHitMasks) drawHitMasks(hitMasks, m_name + "_fail_e" + std::to_string(m_event));
  
     m_event++;
     return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode FPGATrackSimHough1DShiftTool::initialize ( )

overridevirtual

Definition at line 46 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     // Config printout
     ATH_MSG_INFO("Phi range: (" << m_phiMin << "," << m_phiMax << "," << m_phiBins << ")");
     if (m_useDiff) ATH_MSG_INFO("useDiff Set True");
     if (m_variableExtend) ATH_MSG_INFO("variableExtend Set True");
     ATH_MSG_INFO("enhancedHighPt " << m_enhanceHighPt.value());
     ATH_MSG_INFO("applyDropable " << m_applyDropable.value());
     ATH_MSG_INFO("threshold " << m_threshold.value());
     
     // Retrieve info
     if (m_idealGeoRoads || m_useSectors) ATH_CHECK(m_FPGATrackSimBankSvc.retrieve());
     ATH_CHECK(m_FPGATrackSimMapping.retrieve());
     m_nLayers = m_FPGATrackSimMapping->PlaneMap_1st()->getNLogiLayers();
  
     // Error checking
     if (m_phiMin >= m_phiMax || m_phiBins == 0u) {
         ATH_MSG_FATAL("initialize() Phi range invalid");
     return StatusCode::FAILURE;
     }
  
     // Fix inputs
     if (!m_hitExtendProperty.value().empty()) {
       if (m_hitExtendProperty.value().size() != m_nLayers) {
     ATH_MSG_FATAL("initialize() Hit extend must have size == nLayers");
     return StatusCode::FAILURE;
       } else {
     m_hitExtend = m_hitExtendProperty.value();
       }
     } else {
       m_hitExtend.resize(m_nLayers,0); // all 0
     }
     if (m_iterStep == 0u) m_iterStep = m_hitExtend[m_iterLayer] * 2 + 1; // default 1
  
     // Copy correct r values from the region map.
     m_r.resize(m_nLayers);
     for (unsigned ilayer = 0; ilayer < m_nLayers; ilayer++) {
         m_r[ilayer] = m_FPGATrackSimMapping->SubRegionMap()->getAvgRadius(m_subRegion, ilayer);
     }
  
     // Warnings / corrections
      if (m_idealGeoRoads)
     {
         if (m_useSectors)
         {
             ATH_MSG_WARNING("initialize() idealGeoRoads conflicts with useSectors, switching off FPGATrackSim sector matching");
             m_useSectors = false;
         }
         if (!m_traceHits)
         {
             ATH_MSG_WARNING("initialize() idealGeoRoads requires tracing hits, turning on automatically");
             m_traceHits = true;
         }
     }
  
     // Fill convenience variables
     m_phiStep = (m_phiMax - m_phiMin) / m_phiBins;
     for (unsigned i = 0; i <= m_phiBins; i++)
         m_bins.push_back(m_phiMin + m_phiStep * i);
     m_regionMin = m_EvtSel->getRegions()->getMin(m_EvtSel->getRegionID());
     m_regionMax = m_EvtSel->getRegions()->getMax(m_EvtSel->getRegionID());
  
     m_regionMin.phi = m_regionMin.phi - 0.01; // For phi boundary effect   
     m_regionMax.phi = m_regionMax.phi + 0.01; // For phi boundary effect 
  
     m_currentcounts.resize(m_phiBins);
  
     // Calculate the shift amounts
     if (m_bitShift_path.value().empty()) calculateShifts();
     else readShifts(m_bitShift_path);
     printShifts();
  
  
     return StatusCode::SUCCESS;
 }

◆ makeHitMasks()

std::vector< boost::dynamic_bitset<> > FPGATrackSimHough1DShiftTool::makeHitMasks ( const std::vector< std::shared_ptr< const FPGATrackSimHit >> & hits )

private

Definition at line 418 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     std::vector<boost::dynamic_bitset<>> hitMasks(m_nLayers, boost::dynamic_bitset<>(m_phiBins));
     for (auto const &hit : hits)
     {
         if (m_subRegion >= 0 && !m_FPGATrackSimMapping->SubRegionMap()->isInRegion(m_subRegion, *hit)) continue;
  
         auto bins = getBins(hit);
  
         for (int i = std::max(bins.first, 0); i <= std::min(bins.second, (int)m_phiBins - 1); i++)
             hitMasks[hit->getLayer()][i] = true;
     }
  
     return hitMasks;
 }

◆ makeRoad()

FPGATrackSimRoad FPGATrackSimHough1DShiftTool::makeRoad	(	const std::vector< std::shared_ptr< const FPGATrackSimHit >> &	hits,
		int	bin_track,
		size_t	iShift
	)

private

Definition at line 435 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     std::vector<int> const & shifts = m_shifts[iShift];
     float qpT = m_qpt[iShift];
  
     std::vector<std::shared_ptr<const FPGATrackSimHit>> road_hits;
     layer_bitmask_t hitLayers = 0;
  
     for (const auto & hit : hits)
     {
         if (m_subRegion >= 0 && !m_FPGATrackSimMapping->SubRegionMap()->isInRegion(m_subRegion, *hit)) continue;
  
         // Get the shifted bins of the hit
         auto bins = getBins(hit);
         bins.first += shifts[hit->getLayer()]; // note boost::dynamic_bitset stores [0] as the LSB, i.e. rightmost. So leftshift = +bin
         bins.second += shifts[hit->getLayer()];
  
         // Check if it's the same bin as the track
         if (bin_track >= bins.first && bin_track <= bins.second)
         {
             road_hits.push_back(hit);
             hitLayers |= 1 << hit->getLayer();
      }
     }
  
     auto sorted_hits = ::sortByLayer(road_hits);
     sorted_hits.resize(m_nLayers); // If no hits in last layer, return from sortByLayer will be too short
     // Combination of last two addRoad() functions from FPGATrackSimHoughTransformTool.cxx are implemented above (up to here)
     // Below want to look at first addRoad()/matchIdealGeoSector() function in FPGATrackSimHoughTransformTool.cxx
  
     FPGATrackSimRoad r;
     r.setHitLayers(hitLayers);
     r.setHits(std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>>(sorted_hits));
     r.setSubRegion(m_subRegion);
     if (m_fieldCorrection) {
       int inner_bin = static_cast<int>(bin_track)-static_cast<int>(shifts[0]);
       if ((inner_bin < 0) || (inner_bin >= static_cast<int>(m_phiBins))) {
     r.setX(-100000);
       } else {
     r.setX(m_bins[inner_bin] + 0.5*m_phiStep + deltaPhi(m_r[0],qpT));
       }
     } else {
       r.setX(phitrk(bin_track,shifts).first); // will be a large negative number if invalid
     }
     r.setY(qpT);
  
     if (m_useSectors) r.setSector(m_FPGATrackSimBankSvc->SectorBank_1st()->findSector(sorted_hits));
     else if (m_idealGeoRoads) matchIdealGeoSector(r);
  
     return r;
     // TODO sector, wildcard layers?
 }

◆ matchIdealGeoSector()

void FPGATrackSimHough1DShiftTool::matchIdealGeoSector ( FPGATrackSimRoad & r ) const

private

Definition at line 489 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     // We now look up the binning information in the sector bank.
     const FPGATrackSimSectorBank* sectorbank = m_FPGATrackSimBankSvc->SectorBank_1st();
  
     // 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);
     }
  
     int sectorbin = 0;
  
     // Retrieve the bin boundaries from the sector bank; map this onto them.
     std::vector<double> qoverpt_bins = sectorbank->getQOverPtBins();
     auto bounds = std::equal_range(qoverpt_bins.begin(), qoverpt_bins.end(), qoverpt);
  
     sectorbin = fpgatracksim::QPT_SECTOR_OFFSET*(bounds.first - qoverpt_bins.begin() - 1);
     if (sectorbin < 0) sectorbin = 0;
     if ((sectorbin / 10) > static_cast<int>(qoverpt_bins.size() - 2))sectorbin = 10*(qoverpt_bins.size() - 2);
  
     if (m_doRegionalMapping){
       int subregion = r.getSubRegion();
       sectorbin += subregion*fpgatracksim::SUBREGION_SECTOR_OFFSET;
     }
     std::vector<module_t> modules;
     for (unsigned int il = 0; il < r.getNLayers(); il++) {
         if (r.getNHits_layer()[il] == 0) {
             modules.push_back(-1);
  
             layer_bitmask_t wc_layers = r.getWCLayers();
             wc_layers |= (0x1 << il);
             r.setWCLayers(wc_layers);
  
             std::unique_ptr<FPGATrackSimHit> wcHit = std::make_unique<FPGATrackSimHit>();
             wcHit->setHitType(HitType::wildcard);
             wcHit->setLayer(il);
             wcHit->setDetType(m_FPGATrackSimMapping->PlaneMap_1st()->getDetType(il));
             std::vector<std::shared_ptr<const FPGATrackSimHit>> wcHits;
             wcHits.push_back(std::move(wcHit));
             r.setHits(il,std::move(wcHits));
         }
         else {
             modules.push_back(sectorbin);
         }
     }
  
     // 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));
     }
 }

◆ passThreshold()

bool FPGATrackSimHough1DShiftTool::passThreshold	(	std::vector< boost::dynamic_bitset<>> &	binHits,
		int	bin
	)		const

private

Definition at line 382 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     // Check the threshold
     if (binHits[bin].count() <  m_threshold) return false;
  
     // Apply neighbor veto
     if (m_neighborWindow>0) {
     for (int i = -m_neighborWindow; i <= m_neighborWindow; i++) {
         if ((bin+i < 0) or ((bin+i)>=int(m_phiBins))) continue; // ignore edges
         if (binHits[bin+i].count()>binHits[bin].count()) {
         // neighbor has more layers
         return false;
         }
         if (i!=0 && (binHits[bin+i].count()==binHits[bin].count())) {
         // favor lower phi bin
         return false;
         }
         for (unsigned j = 0; j < m_vetolist.size(); j++) {
         if (m_vetolist[j][bin+i]>binHits[bin].count()) {
             // past neighbor has more layers
             return false;
         }
         if ((m_vetolist[j][bin+i]==binHits[bin].count()) and (i<0)) {
             // favor previous shift and lower phi bin
             return false;
         }
         }
     }
     }
  
     return true; // passed threshold, wasn't vetoed by neighbors
  
 }

◆ phitrk()

std::pair< float, bool > FPGATrackSimHough1DShiftTool::phitrk	(	int	bin,
		std::vector< int > const &	shifts
	)		const

private

Definition at line 605 of file FPGATrackSimHough1DShiftTool.cxx.

 {
   int inner_bin = static_cast<int>(bin)-static_cast<int>(shifts[0]);
   int outer_bin = static_cast<int>(bin)-static_cast<int>(shifts[m_nLayers-1]);
   if ((inner_bin < 0) || (inner_bin >= static_cast<int>(m_phiBins))) return {-100000,false};
   if ((outer_bin < 0) || (outer_bin >= static_cast<int>(m_phiBins))) return {-100000,false};
   float phi1 = m_bins[inner_bin];
   float phi2 = m_bins[outer_bin];
   float phi_track = phitrkDiff(m_r[0],phi1,m_r[m_nLayers-1],phi2)+0.5*m_phiStep;
   return {phi_track,true};
 }

◆ phitrkDiff()

float FPGATrackSimHough1DShiftTool::phitrkDiff	(	float	r1,
		float	phi1,
		float	r2,
		float	phi2
	)		const

private

Definition at line 598 of file FPGATrackSimHough1DShiftTool.cxx.

 {
    float phi_track = phi1+ std::atan2(r2-r1*std::cos(phi2-phi1),r1*std::sin(phi2-phi1)) - TMath::Pi()/2.0;
   return phi_track;
 }

◆ printHitMasks()

void FPGATrackSimHough1DShiftTool::printHitMasks ( std::vector< boost::dynamic_bitset<>> const & hitMasks ) const

private

Definition at line 665 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     std::stringstream ss;
     ss << "Hit Masks:\n";
     for (auto const & b : hitMasks)
     {
         ss << "\t";
         for (size_t i = 0; i < b.size(); i++)
         {
             if (b[i]) ss << 1;
             else ss << ".";
         }
         ss << "\n";
     }
     ATH_MSG_DEBUG(ss.str() << "\n\n");
 }

◆ printShifts()

void FPGATrackSimHough1DShiftTool::printShifts ( ) const

private

Definition at line 707 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     std::stringstream ss;
     ss << "Shifts:\n";
     for (size_t i = 0; i < m_shifts.size(); i++)
     {
         float qpt = qPt(m_r[m_iterLayer], m_phiStep * m_shifts[i][m_iterLayer]); // q/pT represented by this shift
         ss << "q/pT=" << qpt << "; ";
         for (int shift : m_shifts[i]) ss << shift << " ";
         if (!m_dropable.empty()) ss << m_dropable[i];
         ss << "\n";
     }
     ATH_MSG_VERBOSE(ss.str());
 }

◆ qPt()

float FPGATrackSimHough1DShiftTool::qPt	(	float	r,
		float	deltaPhi
	)		const

private

Definition at line 587 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     if (m_useDiff) {
       float r1=m_r[0];
       float r2=r;
       float sign = deltaPhi>0 ? 1 : -1;
       return sign*1/(2*fpgatracksim::A) * std::sqrt((4*std::sin(deltaPhi)*std::sin(deltaPhi))/( r1*r1 + r2*r2 -2*r2*r1*std::cos(deltaPhi)));
     }
     return std::sin(deltaPhi) / (fpgatracksim::A * r);
 }

◆ readShifts()

void FPGATrackSimHough1DShiftTool::readShifts ( std::string const & filepath )

private

Definition at line 190 of file FPGATrackSimHough1DShiftTool.cxx.

 {
     // Open the file
     std::ifstream fin(filepath);
     if (!fin.is_open())
     {
         ATH_MSG_FATAL("Couldn't open " << filepath);
         throw ("FPGATrackSimHough1DShiftTool::readShifts couldn't open " + filepath);
     }
  
     // Variables to fill
     std::string line;
     bool ok = true;
     int subregion = -1;
     bool newsubr = false;
     bool headerdone = false;
     int nslices = 0;
     int nphi=0;
  
  
     // Parse the file
     while (getline(fin, line))
     {
     newsubr|=(line.empty());
         if (line.empty() || line[0] == '#') continue;
         std::istringstream sline(line);
     if (!headerdone) {
         std::string towers, phi;
         ok = ok && (sline >> towers);
         if (towers!="towers") {
         ATH_MSG_FATAL("Parse Error expected 'towers' got "<< towers);
         throw ("FPGATrackSimHough1DShiftTool::readShifts couldn't parse " + filepath);
         }
         ok = ok && (sline >> nslices);
         ATH_MSG_INFO("FPGATrackSimHough1DShiftTool::readShifts " << nslices << "slices in shift file");
         ok = ok && (sline >> phi);
         if (phi!="phi") {
         ATH_MSG_FATAL("Parse Error expected 'phi' got "<< phi);
         throw ("FPGATrackSimHough1DShiftTool::readShifts couldn't parse " + filepath);
         }
         ok = ok && (sline >> nphi);
         headerdone=true;
         continue;
     }
  
     if (newsubr) {
         ok = ok && (sline >> subregion);
         ATH_MSG_INFO("FPGATrackSimHough1DShiftTool::readShifts " << subregion << " looking for " << m_subRegion);
         newsubr=false;
         continue;
     }
  
     if (subregion==m_subRegion) {
         ATH_MSG_INFO("FPGATrackSimHough1DShiftTool::readShifts found subregion " << m_subRegion);
         // Shifts
         std::vector<int> shifts;
         shifts.push_back(0); // layer 0 is implicit 0 TODO
         for (unsigned layer = 1; layer < m_nLayers; layer++)
         {
         int shift = 0;
         ok = ok && (sline >> shift);
         if (!ok) break;
         shifts.push_back(shift);
         }
         if (!ok) break;
         if (shifts[0]<-1000) {
         ATH_MSG_INFO("FPGATrackSimHough1DShiftTool::readShifts skipping line with shift out of range: " << line);
         continue;
         }
  
         // Dropable
         std::string droplist;
         ok = ok && (sline >> droplist);
         ok = ok && (droplist.size() == m_nLayers);
         if (!ok) break;
  
         boost::dynamic_bitset<> drops(m_nLayers);
         for (unsigned i = 0; i < m_nLayers; i++)
           if (droplist[i] == '1')
                 drops[m_nLayers - i - 1] = true; // Droplist is printed with MSB on left
  
         // qpT
         float qpt = 0;
         ok = ok && (sline >> qpt);
         if (!ok) break;
         if ((qpt<m_qptMin) or (qpt>m_qptMax)) continue;
  
         // Phi Vals
         std::vector<float> phivals;
         for (unsigned layer = 0; layer < m_nLayers; layer++)
         {
         float phival = 0;
         ok = ok && (sline >> phival);
         if (!ok) break;
         phivals.push_back(phival);
         }
  
         m_qpt.push_back(qpt);
         m_shifts.push_back(shifts);
         m_dropable.push_back(drops);
         m_phivals.push_back(phivals);
  
  
     }
     }
  
     if (!ok)
     {
         ATH_MSG_FATAL("Found error reading file at line: " << line);
         throw "FPGATrackSimHough1DShiftTool::readShifts read error";
     }
  
     if (m_shifts.size()==0) ATH_MSG_FATAL("FPGATrackSimHough1DShiftTool::readShifts no shifts read");
     ATH_MSG_INFO("Read " << m_shifts.size() << " patterns from " << filepath);
 }

◆ shiftWithDrop()

std::vector< int > FPGATrackSimHough1DShiftTool::shiftWithDrop	(	std::vector< int > &	shift,
		unsigned	droplayer
	)		const

private

Definition at line 756 of file FPGATrackSimHough1DShiftTool.cxx.

 {
   std::vector<int> retv(m_nLayers-1);
   for (unsigned lyr = 0; lyr < m_nLayers; lyr++) {
     if (lyr !=droplayer) retv.push_back(shift[lyr]);
   }
   return retv;
 }

Member Data Documentation

◆ m_applyDropable

Gaudi::Property<bool> FPGATrackSimHough1DShiftTool::m_applyDropable { this, "applyDropable", false, "Enable logic that prevents redundant patterns with dropped hits" }

private

Definition at line 139 of file FPGATrackSimHough1DShiftTool.h.

◆ m_bins

std::vector<double> FPGATrackSimHough1DShiftTool::m_bins

private

Definition at line 155 of file FPGATrackSimHough1DShiftTool.h.

◆ m_bitShift_path

Gaudi::Property<std::string> FPGATrackSimHough1DShiftTool::m_bitShift_path { this, "bitShifts", "", "Instead of calculating bit shifts, input a list of shifts via a text file" }

private

Definition at line 138 of file FPGATrackSimHough1DShiftTool.h.

◆ m_currentcounts

std::vector<unsigned> FPGATrackSimHough1DShiftTool::m_currentcounts

private

Definition at line 169 of file FPGATrackSimHough1DShiftTool.h.

◆ m_d0shifts

std::vector<std::vector<int> > FPGATrackSimHough1DShiftTool::m_d0shifts

private

Definition at line 168 of file FPGATrackSimHough1DShiftTool.h.

◆ m_d0spread

Gaudi::Property<float> FPGATrackSimHough1DShiftTool::m_d0spread {this, "d0spread", -1.0, "Make patterns with a d0spread as given, negative value turns it off" }

private

Definition at line 136 of file FPGATrackSimHough1DShiftTool.h.

◆ m_doEtaPatternConsts

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

private

Definition at line 114 of file FPGATrackSimHough1DShiftTool.h.

◆ m_doRegionalMapping

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

private

Definition at line 118 of file FPGATrackSimHough1DShiftTool.h.

◆ m_drawHitMasks

Gaudi::Property<bool> FPGATrackSimHough1DShiftTool::m_drawHitMasks { this, "drawHitMasks", false, "Draws hit masks if true"}

private

Definition at line 119 of file FPGATrackSimHough1DShiftTool.h.

◆ m_dropable

std::vector<boost::dynamic_bitset<> > FPGATrackSimHough1DShiftTool::m_dropable

private

Definition at line 163 of file FPGATrackSimHough1DShiftTool.h.

◆ m_enhanceHighPt

Gaudi::Property<float> FPGATrackSimHough1DShiftTool::m_enhanceHighPt {this, "enhanceHighPt", -1.0, "if positive, double number of patterns for region with qpT below value" }

private

Definition at line 143 of file FPGATrackSimHough1DShiftTool.h.

◆ m_event

unsigned FPGATrackSimHough1DShiftTool::m_event = 0

private

Definition at line 181 of file FPGATrackSimHough1DShiftTool.h.

◆ m_EvtSel

ServiceHandle<IFPGATrackSimEventSelectionSvc> FPGATrackSimHough1DShiftTool::m_EvtSel {this, "FPGATrackSimEventSelectionSvc", "FPGATrackSimEventSelectionSvc"}

private

Definition at line 105 of file FPGATrackSimHough1DShiftTool.h.

◆ m_fieldCorrection

Gaudi::Property<bool> FPGATrackSimHough1DShiftTool::m_fieldCorrection {this, "fieldCorrection", true, "Apply corrections to hough equation due to field nonuniformity" }

private

Definition at line 142 of file FPGATrackSimHough1DShiftTool.h.

◆ m_FPGATrackSimBankSvc

ServiceHandle<IFPGATrackSimBankSvc> FPGATrackSimHough1DShiftTool::m_FPGATrackSimBankSvc {this, "FPGATrackSimBankSvc", "FPGATrackSimBankSvc"}

private

Definition at line 106 of file FPGATrackSimHough1DShiftTool.h.

◆ m_FPGATrackSimMapping

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

private

Definition at line 107 of file FPGATrackSimHough1DShiftTool.h.

◆ m_historyWindow

Gaudi::Property<unsigned> FPGATrackSimHough1DShiftTool::m_historyWindow {this, "historyWindow", 0, "Suppress if previous N bit shifts have neighbors with higher nubmer of hit layers" }

private

Definition at line 141 of file FPGATrackSimHough1DShiftTool.h.

◆ m_hitExtend

std::vector<float> FPGATrackSimHough1DShiftTool::m_hitExtend

private

Definition at line 146 of file FPGATrackSimHough1DShiftTool.h.

◆ m_hitExtendProperty

Gaudi::Property<std::vector<float> > FPGATrackSimHough1DShiftTool::m_hitExtendProperty {this, "hitExtend", {}, "Number of adjacent bins that a hit triggers" }

private

Definition at line 137 of file FPGATrackSimHough1DShiftTool.h.

◆ m_idealGeoRoads

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

private

Definition at line 117 of file FPGATrackSimHough1DShiftTool.h.

◆ m_iterLayer

Gaudi::Property<unsigned> FPGATrackSimHough1DShiftTool::m_iterLayer { this, "iterLayer", 0, "Instead of iterating over steps in pT, we iterate over iterStep-bin shifts in iterLayer" }

private

Definition at line 130 of file FPGATrackSimHough1DShiftTool.h.

◆ m_iterStep

Gaudi::Property<unsigned> FPGATrackSimHough1DShiftTool::m_iterStep { this, "iterStep", 0, "Instead of iterating over steps in pT, we iterate over iterStep-bin shifts in iterLayer" }

private

Definition at line 129 of file FPGATrackSimHough1DShiftTool.h.

◆ m_monitorFile

TFile FPGATrackSimHough1DShiftTool::m_monitorFile

private

Definition at line 183 of file FPGATrackSimHough1DShiftTool.h.

◆ m_name

std::string FPGATrackSimHough1DShiftTool::m_name

private

Definition at line 182 of file FPGATrackSimHough1DShiftTool.h.

◆ m_neighborWindow

Gaudi::Property<int> FPGATrackSimHough1DShiftTool::m_neighborWindow { this, "neighborWindow", 0, "Supress if neighbors have higher number of hit layers" }

private

Definition at line 140 of file FPGATrackSimHough1DShiftTool.h.

◆ m_nLayers

unsigned FPGATrackSimHough1DShiftTool::m_nLayers

private

Definition at line 152 of file FPGATrackSimHough1DShiftTool.h.

◆ m_phiBins

Gaudi::Property<unsigned> FPGATrackSimHough1DShiftTool::m_phiBins { this, "nBins", 0, "Number of phi bins used by transform." }

private

Definition at line 127 of file FPGATrackSimHough1DShiftTool.h.

◆ m_phiMax

Gaudi::Property<float> FPGATrackSimHough1DShiftTool::m_phiMax { this, "phiMax", 0, "Maximum phi of transform" }

private

Definition at line 123 of file FPGATrackSimHough1DShiftTool.h.

◆ m_phiMin

Gaudi::Property<float> FPGATrackSimHough1DShiftTool::m_phiMin { this, "phiMin", 0, "Minimum phi of transform" }

private

Definition at line 122 of file FPGATrackSimHough1DShiftTool.h.

◆ m_phiRangeCut

Gaudi::Property<bool> FPGATrackSimHough1DShiftTool::m_phiRangeCut {this, "phiRangeCut", false, "Require tracks to be in phi range to avoid counting minbias roads for larger region" }

private

Definition at line 134 of file FPGATrackSimHough1DShiftTool.h.

◆ m_phiStep

float FPGATrackSimHough1DShiftTool::m_phiStep

private

Definition at line 154 of file FPGATrackSimHough1DShiftTool.h.

◆ m_phivals

std::vector<std::vector<float> > FPGATrackSimHough1DShiftTool::m_phivals

private

Definition at line 167 of file FPGATrackSimHough1DShiftTool.h.

◆ m_qpt

std::vector<float> FPGATrackSimHough1DShiftTool::m_qpt

private

Definition at line 166 of file FPGATrackSimHough1DShiftTool.h.

◆ m_qptMax

Gaudi::Property<float> FPGATrackSimHough1DShiftTool::m_qptMax { this, "qptMax", 0, "Maximum q/pT of transform" }

private

Definition at line 125 of file FPGATrackSimHough1DShiftTool.h.

◆ m_qptMin

Gaudi::Property<float> FPGATrackSimHough1DShiftTool::m_qptMin { this, "qptMin", 0, "Minimum q/pT of transform" }

private

Definition at line 124 of file FPGATrackSimHough1DShiftTool.h.

◆ m_r

std::vector<float> FPGATrackSimHough1DShiftTool::m_r

private

Definition at line 147 of file FPGATrackSimHough1DShiftTool.h.

◆ m_regionMax

FPGATrackSimTrackPars FPGATrackSimHough1DShiftTool::m_regionMax

private

Definition at line 160 of file FPGATrackSimHough1DShiftTool.h.

◆ m_regionMin

FPGATrackSimTrackPars FPGATrackSimHough1DShiftTool::m_regionMin

private

Definition at line 159 of file FPGATrackSimHough1DShiftTool.h.

◆ m_roads

std::vector<FPGATrackSimRoad> FPGATrackSimHough1DShiftTool::m_roads

private

Definition at line 176 of file FPGATrackSimHough1DShiftTool.h.

◆ m_shifts

std::vector<std::vector<int> > FPGATrackSimHough1DShiftTool::m_shifts

private

Definition at line 162 of file FPGATrackSimHough1DShiftTool.h.

◆ m_subRegion

Gaudi::Property<int> FPGATrackSimHough1DShiftTool::m_subRegion { this, "subRegion", 0, "Sub region of this transform, or -1 for full region" }

private

Definition at line 121 of file FPGATrackSimHough1DShiftTool.h.

◆ m_threshold

Gaudi::Property<unsigned> FPGATrackSimHough1DShiftTool::m_threshold { this, "threshold", 0, "Minimum number of layers hit to accept as a road (inclusive)" }

private

Definition at line 128 of file FPGATrackSimHough1DShiftTool.h.

◆ m_traceHits

Gaudi::Property<bool> FPGATrackSimHough1DShiftTool::m_traceHits { this, "traceHits", true, "Trace each hit that goes in a bin. Disabling this will save memory/time since each bin doesn't have to store all its hits but the roads created won't have hits from convolution, etc."}

private

Definition at line 112 of file FPGATrackSimHough1DShiftTool.h.

◆ m_useDiff

Gaudi::Property<bool> FPGATrackSimHough1DShiftTool::m_useDiff { this, "useDiff", false, "Use the diff of inner and outer layer" }

private

Definition at line 132 of file FPGATrackSimHough1DShiftTool.h.

◆ m_useSectors

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

private

Definition at line 116 of file FPGATrackSimHough1DShiftTool.h.

◆ m_useSpacePoints

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

private

Definition at line 115 of file FPGATrackSimHough1DShiftTool.h.

◆ m_variableExtend

Gaudi::Property<bool> FPGATrackSimHough1DShiftTool::m_variableExtend { this, "variableExtend", false, "Do variable extension based off of hit delta R" }

private

Definition at line 133 of file FPGATrackSimHough1DShiftTool.h.

◆ m_vetolist

std::deque<std::vector<unsigned> > FPGATrackSimHough1DShiftTool::m_vetolist

private

Definition at line 170 of file FPGATrackSimHough1DShiftTool.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FPGATrackSimHough1DShiftTool()

Member Function Documentation

◆ applyVariation()

◆ calculated0Shifts()

◆ calculateDropable()

◆ calculateShifts()

◆ deltaPhi()

◆ drawHitMasks() [1/2]

◆ drawHitMasks() [2/2]

◆ finalize()

◆ getBins()

◆ getPtFromShiftDiff()

◆ getRoads()

◆ initialize()

◆ makeHitMasks()

◆ makeRoad()

◆ matchIdealGeoSector()

◆ passThreshold()

◆ phitrk()

◆ phitrkDiff()

◆ printHitMasks()

◆ printShifts()

◆ qPt()

◆ readShifts()

◆ shiftWithDrop()

Member Data Documentation

◆ m_applyDropable

◆ m_bins

◆ m_bitShift_path

◆ m_currentcounts

◆ m_d0shifts

◆ m_d0spread

◆ m_doEtaPatternConsts

◆ m_doRegionalMapping

◆ m_drawHitMasks

◆ m_dropable

◆ m_enhanceHighPt

◆ m_event

◆ m_EvtSel

◆ m_fieldCorrection

◆ m_FPGATrackSimBankSvc

◆ m_FPGATrackSimMapping

◆ m_historyWindow

◆ m_hitExtend

◆ m_hitExtendProperty

◆ m_idealGeoRoads

◆ m_iterLayer

◆ m_iterStep

◆ m_monitorFile

◆ m_name

◆ m_neighborWindow

◆ m_nLayers

◆ m_phiBins

◆ m_phiMax

◆ m_phiMin

◆ m_phiRangeCut

◆ m_phiStep

◆ m_phivals

◆ m_qpt

◆ m_qptMax

◆ m_qptMin

◆ m_r

◆ m_regionMax

◆ m_regionMin

◆ m_roads

◆ m_shifts

◆ m_subRegion

◆ m_threshold

◆ m_traceHits

◆ m_useDiff

◆ m_useSectors

◆ m_useSpacePoints

◆ m_variableExtend

◆ m_vetolist