FPGATrackSimHough1DShiftTool Class Reference

#include <FPGATrackSimHough1DShiftTool.h>

Inheritance diagram for FPGATrackSimHough1DShiftTool:

Public Member Functions
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
virtual int	getSubRegion () const 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)
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", ""}
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 = 0
float	m_phiStep = 0
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.

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 668 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 649 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(std::move(d0shift));
      if (d0step>m_d0spread) break;
      ++steps;
    }
    ATH_MSG_DEBUG("d0 Shifts Found = " << m_d0shifts.size());
}

calculateDropable()

void FPGATrackSimHough1DShiftTool::calculateDropable ( )

private

Definition at line 691 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]=std::move(drops);
 
  }
 
}

calculateShifts()

void FPGATrackSimHough1DShiftTool::calculateShifts ( )

private

Definition at line 115 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(std::move(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 544 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 608 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 624 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 298 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 490 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 482 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 307 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;
}

getSubRegion()

virtual int FPGATrackSimHough1DShiftTool::getSubRegion ( ) const

inlineoverridevirtual

Definition at line 97 of file FPGATrackSimHough1DShiftTool.h.

{return m_subRegion;}

initialize()

StatusCode FPGATrackSimHough1DShiftTool::initialize ( )

overridevirtual

Definition at line 37 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(0)->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 409 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 426 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>>>(std::move(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);
 
    return r;
    // TODO sector, wildcard layers?
}

passThreshold()

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

private

Definition at line 373 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 531 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 524 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 591 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 633 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 513 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 181 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(std::move(shifts));
        m_dropable.push_back(std::move(drops));
        m_phivals.push_back(std::move(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 682 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 136 of file FPGATrackSimHough1DShiftTool.h.

{ this, "applyDropable", false, "Enable logic that prevents redundant patterns with dropped hits" };

m_bins

std::vector<double> FPGATrackSimHough1DShiftTool::m_bins

private

Definition at line 152 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 135 of file FPGATrackSimHough1DShiftTool.h.

{ this, "bitShifts", "", "Instead of calculating bit shifts, input a list of shifts via a text file" };

m_currentcounts

std::vector<unsigned> FPGATrackSimHough1DShiftTool::m_currentcounts

private

Definition at line 166 of file FPGATrackSimHough1DShiftTool.h.

m_d0shifts

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

private

Definition at line 165 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 133 of file FPGATrackSimHough1DShiftTool.h.

{this, "d0spread", -1.0, "Make patterns with a d0spread as given, negative value turns it off" };

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 111 of file FPGATrackSimHough1DShiftTool.h.

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

m_doRegionalMapping

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

private

Definition at line 115 of file FPGATrackSimHough1DShiftTool.h.

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

m_drawHitMasks

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

private

Definition at line 116 of file FPGATrackSimHough1DShiftTool.h.

{ this, "drawHitMasks", false, "Draws hit masks if true"};

m_dropable

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

private

Definition at line 160 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 140 of file FPGATrackSimHough1DShiftTool.h.

{this, "enhanceHighPt", -1.0, "if positive, double number of patterns for region with qpT below value" };

m_event

unsigned FPGATrackSimHough1DShiftTool::m_event = 0

private

Definition at line 178 of file FPGATrackSimHough1DShiftTool.h.

m_EvtSel

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

private

Definition at line 102 of file FPGATrackSimHough1DShiftTool.h.

{this, "FPGATrackSimEventSelectionSvc", ""};

m_fieldCorrection

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

private

Definition at line 139 of file FPGATrackSimHough1DShiftTool.h.

{this, "fieldCorrection", true, "Apply corrections to hough equation due to field nonuniformity" };

m_FPGATrackSimBankSvc

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

private

Definition at line 103 of file FPGATrackSimHough1DShiftTool.h.

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

m_FPGATrackSimMapping

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

private

Definition at line 104 of file FPGATrackSimHough1DShiftTool.h.

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

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 138 of file FPGATrackSimHough1DShiftTool.h.

{this, "historyWindow", 0, "Suppress if previous N bit shifts have neighbors with higher nubmer of hit layers" };

m_hitExtend

std::vector<float> FPGATrackSimHough1DShiftTool::m_hitExtend

private

Definition at line 143 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 134 of file FPGATrackSimHough1DShiftTool.h.

{this, "hitExtend", {}, "Number of adjacent bins that a hit triggers" };

m_idealGeoRoads

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

private

Definition at line 114 of file FPGATrackSimHough1DShiftTool.h.

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

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 127 of file FPGATrackSimHough1DShiftTool.h.

{ this, "iterLayer", 0, "Instead of iterating over steps in pT, we iterate over iterStep-bin shifts in iterLayer" };

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 126 of file FPGATrackSimHough1DShiftTool.h.

{ this, "iterStep", 0, "Instead of iterating over steps in pT, we iterate over iterStep-bin shifts in iterLayer" };

m_monitorFile

TFile FPGATrackSimHough1DShiftTool::m_monitorFile

private

Definition at line 180 of file FPGATrackSimHough1DShiftTool.h.

m_name

std::string FPGATrackSimHough1DShiftTool::m_name

private

Definition at line 179 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 137 of file FPGATrackSimHough1DShiftTool.h.

{ this, "neighborWindow", 0, "Supress if neighbors have higher number of hit layers" };

m_nLayers

unsigned FPGATrackSimHough1DShiftTool::m_nLayers = 0

private

Definition at line 149 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 124 of file FPGATrackSimHough1DShiftTool.h.

{ this, "nBins", 0, "Number of phi bins used by transform." };

m_phiMax

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

private

Definition at line 120 of file FPGATrackSimHough1DShiftTool.h.

{ this, "phiMax", 0, "Maximum phi of transform" };

m_phiMin

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

private

Definition at line 119 of file FPGATrackSimHough1DShiftTool.h.

{ this, "phiMin", 0, "Minimum phi of transform" };

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 131 of file FPGATrackSimHough1DShiftTool.h.

{this, "phiRangeCut", false, "Require tracks to be in phi range to avoid counting minbias roads for larger region" };

m_phiStep

float FPGATrackSimHough1DShiftTool::m_phiStep = 0

private

Definition at line 151 of file FPGATrackSimHough1DShiftTool.h.

m_phivals

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

private

Definition at line 164 of file FPGATrackSimHough1DShiftTool.h.

m_qpt

std::vector<float> FPGATrackSimHough1DShiftTool::m_qpt

private

Definition at line 163 of file FPGATrackSimHough1DShiftTool.h.

m_qptMax

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

private

Definition at line 122 of file FPGATrackSimHough1DShiftTool.h.

{ this, "qptMax", 0, "Maximum q/pT of transform" };

m_qptMin

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

private

Definition at line 121 of file FPGATrackSimHough1DShiftTool.h.

{ this, "qptMin", 0, "Minimum q/pT of transform" };

m_r

std::vector<float> FPGATrackSimHough1DShiftTool::m_r

private

Definition at line 144 of file FPGATrackSimHough1DShiftTool.h.

m_regionMax

FPGATrackSimTrackPars FPGATrackSimHough1DShiftTool::m_regionMax

private

Definition at line 157 of file FPGATrackSimHough1DShiftTool.h.

m_regionMin

FPGATrackSimTrackPars FPGATrackSimHough1DShiftTool::m_regionMin

private

Definition at line 156 of file FPGATrackSimHough1DShiftTool.h.

m_roads

std::vector<FPGATrackSimRoad> FPGATrackSimHough1DShiftTool::m_roads

private

Definition at line 173 of file FPGATrackSimHough1DShiftTool.h.

m_shifts

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

private

Definition at line 159 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 118 of file FPGATrackSimHough1DShiftTool.h.

{ this, "subRegion", 0, "Sub region of this transform, or -1 for full region" };

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 125 of file FPGATrackSimHough1DShiftTool.h.

{ this, "threshold", 0, "Minimum number of layers hit to accept as a road (inclusive)" };

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 109 of file FPGATrackSimHough1DShiftTool.h.

{ 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."};

m_useDiff

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

private

Definition at line 129 of file FPGATrackSimHough1DShiftTool.h.

{ this, "useDiff", false, "Use the diff of inner and outer layer" };

m_useSectors

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

private

Definition at line 113 of file FPGATrackSimHough1DShiftTool.h.

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

m_useSpacePoints

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

private

Definition at line 112 of file FPGATrackSimHough1DShiftTool.h.

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

m_variableExtend

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

private

Definition at line 130 of file FPGATrackSimHough1DShiftTool.h.

{ this, "variableExtend", false, "Do variable extension based off of hit delta R" };

m_vetolist

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

private

Definition at line 167 of file FPGATrackSimHough1DShiftTool.h.

---

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

• FPGATrackSimHough1DShiftTool.h
• FPGATrackSimHough1DShiftTool.cxx