FPGATrackSimEtaPatternFilterTool Class Reference

#include <FPGATrackSimEtaPatternFilterTool.h>

Inheritance diagram for FPGATrackSimEtaPatternFilterTool:

Collaboration diagram for FPGATrackSimEtaPatternFilterTool:

Classes
struct	ModuleId
struct	ModulesToPattern

Public Member Functions
	FPGATrackSimEtaPatternFilterTool (const std::string &, const std::string &, const IInterface *)
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	filterRoads (const std::vector< FPGATrackSimRoad * > &prefilter_roads, std::vector< FPGATrackSimRoad * > &postfilter_roads) override

Private Types
typedef std::vector< ModuleId >	EtaPattern

Private Member Functions
void	readPatterns (std::string const &filepath)
void	buildMap ()
void	resetCounters ()
void	addHitsToMap (FPGATrackSimRoad *r)
void	addRedundantPatterns (std::set< EtaPattern > &usedPatterns, EtaPattern const &currPatt, unsigned nExtra)
FPGATrackSimRoad	buildRoad (std::pair< EtaPattern, layer_bitmask_t > const &patt, FPGATrackSimRoad *origr, int etaPatternID) const
std::string	to_string (const EtaPattern &patt) const
std::string	to_string (const FPGATrackSimRoad &road) const
std::string	to_string (const std::vector< unsigned > &v) const

Private Attributes
ServiceHandle< IFPGATrackSimMappingSvc >	m_FPGATrackSimMapping {this, "FPGATrackSimMappingSvc", "FPGATrackSimMappingSvc"}
ServiceHandle< IFPGATrackSimBankSvc >	m_FPGATrackSimBankSvc {this, "FPGATrackSimBankSvc", "FPGATrackSimBankSvc"}
Gaudi::Property< std::string >	m_pattern_file_path {this, "EtaPatterns", "", "path to pattern file"}
Gaudi::Property< unsigned >	m_threshold {this, "threshold", 0, "Minimum number of hit layers to fire a road"}
Gaudi::Property< bool >	m_isSecondStage {this, "isSecondStage", false, "Whether or not his this a second stage HT"}
Gaudi::Property< bool >	m_doEtaPatternConsts {this, "doEtaPatternConsts", false, "Use eta pattern IDs as part of sector definition"}
Gaudi::Property< bool >	m_dynamicThreshold { this, "dynamicThreshold", false, "Stop lowering the threshold once matches have been found"}
std::vector< FPGATrackSimRoad >	m_postfilter_roads
unsigned	m_nLayers {}
std::map< EtaPattern, layer_bitmask_t >	m_patternmap
std::vector< std::map< ModuleId, ModulesToPattern > >	m_moduleHits

Friends
bool	operator< (const ModuleId &lhs, const ModuleId &rhs)

Detailed Description

Definition at line 35 of file FPGATrackSimEtaPatternFilterTool.h.

Member Typedef Documentation

EtaPattern

typedef std::vector<ModuleId> FPGATrackSimEtaPatternFilterTool::EtaPattern

private

Definition at line 78 of file FPGATrackSimEtaPatternFilterTool.h.

Constructor & Destructor Documentation

FPGATrackSimEtaPatternFilterTool()

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

Definition at line 37 of file FPGATrackSimEtaPatternFilterTool.cxx.

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

Member Function Documentation

addHitsToMap()

void FPGATrackSimEtaPatternFilterTool::addHitsToMap ( FPGATrackSimRoad *  r )

private

Definition at line 213 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    for (unsigned lyr = 0; lyr < m_nLayers; lyr++)
        for (auto & hit : r->getHits(lyr))
            if (hit->getHitType() != HitType::wildcard)
            {
                ModuleId mod = { hit->getDetType(), hit->getDetectorZone(), (int)(hit->getEtaModule()) };
                auto itr = m_moduleHits[lyr].find(mod);
                if (itr != m_moduleHits[lyr].end())
                    itr->second.addHit(hit);
                else {
                    ATH_MSG_ERROR("Module not in map: " << hit->getDetType() << " " << hit->getDetectorZone() << " " <<  static_cast<int>(hit->getEtaModule()) );
                    for (auto & itr2 : m_moduleHits[lyr])
                    {
                        ATH_MSG_ERROR("   " << itr2.first.siTech << " " << itr2.first.zone << " " << itr2.first.etaModule);
                    }
                }
            }
}

addRedundantPatterns()

void FPGATrackSimEtaPatternFilterTool::addRedundantPatterns ( std::set< EtaPattern > &  usedPatterns, EtaPattern const &  currPatt, unsigned  nExtra  )

private

Definition at line 235 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    usedPatterns.insert(currPatt);
 
    std::vector<unsigned> allowmissing(nExtra, 0);
    bool done = false;
    while (!done)
    {
        EtaPattern subpatt(currPatt);
        for (auto h : allowmissing)
            subpatt[h] = {};
        usedPatterns.insert(subpatt);
 
        // increment allowmissing with rollover
        done = (nExtra == 0);
        for (unsigned i = 0; i < nExtra; i++)
        {
            allowmissing[i]++;
            if (allowmissing[i] == m_nLayers)
            {
                allowmissing[i] = 0;
                done = (i==nExtra-1); // incremented last counter so were done
            }
            else
            {
                break;
            }
        }
    }
}

buildMap()

void FPGATrackSimEtaPatternFilterTool::buildMap ( )

private

Definition at line 112 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    ATH_MSG_DEBUG("Building Map ");
    m_moduleHits.resize(m_nLayers);
 
    for (auto & entry : m_patternmap)
    {
        EtaPattern const & patt = entry.first;
        layer_bitmask_t & counter = entry.second;
        for (unsigned lyr = 0; lyr < m_nLayers; lyr++)
            m_moduleHits[lyr][patt[lyr]].addPattern(&counter);
    }
 
    ATH_MSG_DEBUG("Done Building Map ");
}

buildRoad()

FPGATrackSimRoad FPGATrackSimEtaPatternFilterTool::buildRoad ( std::pair< EtaPattern, layer_bitmask_t > const &  patt, FPGATrackSimRoad *  origr, int  etaPatternID  ) const

private

Definition at line 266 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    // All roads are now Hough roads.
    FPGATrackSimRoad r(*origr);
 
    r.setHitLayers(patt.second);
    r.setEtaPatternID(etaPatternID);
    for (unsigned lyr = 0; lyr < m_nLayers; lyr++) {
        r.setHits(lyr, m_moduleHits[lyr].find(patt.first[lyr])->second.getHits());
        if (r.getNHits_layer().at(lyr) == 0) {
            FPGATrackSimHit *wcHit = new FPGATrackSimHit();
            wcHit->setHitType(HitType::wildcard);
            wcHit->setDetType(m_FPGATrackSimMapping->PlaneMap_1st()->getDetType(lyr));
            wcHit->setLayer(lyr);
            r.setHits(lyr, std::vector<const FPGATrackSimHit*>{wcHit});
        }
    }
 
    // Here, if told to do so, we'll reset the road's sector using the eta pattern ID.
    // Perhaps this should also be AND'ed with the "match ideal geometry" setting?
    // This code is adapted from FPGATrackSimHoughTransformTool::matchIdealGeoSectors, which perhaps
    // calls for moving this into the road class itself.
    if (m_doEtaPatternConsts) {
        int sectorbin = fpgatracksim::ETA_SECTOR_OFFSET*etaPatternID + r.getSectorBin();
        r.setSectorBin(sectorbin);
        std::vector<module_t> modules;
        for (unsigned int il = 0; il < r.getNLayers(); il++) {
            if (r.getNHits_layer()[il] == 0) {
                modules.push_back(-1);
            } else {
                modules.push_back(sectorbin);
            }
        }
        const FPGATrackSimSectorBank* sectorbank = !m_isSecondStage ? m_FPGATrackSimBankSvc->SectorBank_1st() : m_FPGATrackSimBankSvc->SectorBank_2nd();
        r.setSector(sectorbank->findSector(modules));
    }
    return r;
}

filterRoads()

StatusCode FPGATrackSimEtaPatternFilterTool::filterRoads ( const std::vector< FPGATrackSimRoad * > &  prefilter_roads, std::vector< FPGATrackSimRoad * > &  postfilter_roads  )

overridevirtual

Definition at line 138 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    m_postfilter_roads.clear();
    postfilter_roads.clear();
    for (auto & road : prefilter_roads)
    {
        // reset all maps
        resetCounters();
    
 
        // put hits in module objects
        addHitsToMap(road);
 
        // keep track of used patterns, don't reuse
        std::set<EtaPattern> usedPatterns;
 
        // Count the number of matches from each individual road. This allows a dynamic threshold
        // during constant generation (where we don't want to discard training tracks).
        // At least, where we *might* not want to discard training tracks?
        int numMatches = 0;
        // check what is above threshold, moving down from 8/8 hits
        for (unsigned working_threshold = m_nLayers; working_threshold >= m_threshold; working_threshold--)
        {
            for (auto & patt_bitmask : m_patternmap)
            {
                unsigned nLayers = __builtin_popcount(patt_bitmask.second);
                if (nLayers >= working_threshold)
                {
                    // create subpattern from layers that actually have hits
                    EtaPattern subpatt(patt_bitmask.first);
                    for (unsigned lyr = 0; lyr < m_nLayers; lyr++)
                        if (!(patt_bitmask.second & (1 << lyr)))
                            subpatt[lyr] = {}; // defaults to undefined enums = missed
 
                    // check if this pattern was used already
                    if (usedPatterns.count(subpatt) > 0) continue;
                    addRedundantPatterns(usedPatterns, subpatt, nLayers - m_threshold);
 
                    // Get an "ID" for the pattern. This is a crude hack but it sort of works
                    // since the keys aren't being changed after the map is created. And provided the
                    // map is created in a consistent order this SHOULD be driven by insertion order.
                    // but this assumption may be fragile.
                    int index = std::distance(m_patternmap.begin(), m_patternmap.find(patt_bitmask.first));
                    if ((uint)index == m_patternmap.size() || index < 0) {
                        ATH_MSG_ERROR("Invalid pattern ID: " << index);
                    }
                    numMatches += 1;
 
                    // make the road
                    m_postfilter_roads.push_back(buildRoad(patt_bitmask, road, index));
                }
            }
            // If using a "dynamic" threshold-- once matches have been found at a given level, exit.
            if (numMatches > 0 && m_dynamicThreshold) {
          break;
            }
        }
    }
    // copy roads to outputs
    postfilter_roads.reserve(m_postfilter_roads.size());
    for (FPGATrackSimRoad & r : m_postfilter_roads)
        postfilter_roads.push_back(&r);
    return StatusCode::SUCCESS;
}

finalize()

StatusCode FPGATrackSimEtaPatternFilterTool::finalize ( )

overridevirtual

Definition at line 129 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    return StatusCode::SUCCESS;
}

initialize()

StatusCode FPGATrackSimEtaPatternFilterTool::initialize ( )

overridevirtual

Definition at line 44 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    // Retrieve info
    ATH_CHECK(m_FPGATrackSimMapping.retrieve());
    ATH_CHECK(m_FPGATrackSimBankSvc.retrieve());
    m_nLayers = m_FPGATrackSimMapping->PlaneMap_1st()->getNLogiLayers();
 
    // Check inputs
    if (m_pattern_file_path.empty())
    {
        ATH_MSG_FATAL("No File Specified");
        return StatusCode::FAILURE;
    }
 
    // Read pattern file, populate m_patternmap keys
    readPatterns(m_pattern_file_path);
 
    // Create inverse map from module to pattern counter, m_moduleHits
    buildMap();
 
    return StatusCode::SUCCESS;
}

readPatterns()

void FPGATrackSimEtaPatternFilterTool::readPatterns ( std::string const &  filepath )

private

Definition at line 68 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
  
    // Open the file
    std::ifstream fin(PathResolverFindCalibFile(filepath));
    if (!fin.is_open())
    {
        ATH_MSG_FATAL("Couldn't open " << filepath);
        throw ("FPGATrackSimEtaPatternFilterTool couldn't open " + filepath);
    }
 
    // Parse the file
    bool ok = true;
    std::string line;
    while (getline(fin, line))
    {
        if (line.empty() || line[0] == '#') continue;
        std::istringstream sline(line);
 
        // Read Pattern
        EtaPattern pattern;
        pattern.resize(m_nLayers);
        int tech, zone, mod;
        for (unsigned layer = 0; layer < m_nLayers; layer++)
        {
            ok = ok && (sline >> tech >> zone >> mod);
            if (!ok) break;
            pattern[layer] = { static_cast<SiliconTech>(tech), static_cast<DetectorZone>(zone), mod };
        }
        if (!ok) break;
 
        m_patternmap.emplace(pattern, 0);
    }
 
    if (!ok)
    {
        ATH_MSG_FATAL("Found error reading file at line: " << line);
        throw "FPGATrackSimEtaPatternFilterTool read error";
    }
 
    ATH_MSG_INFO("Read " << m_patternmap.size() << " patterns from " << filepath);
}

resetCounters()

void FPGATrackSimEtaPatternFilterTool::resetCounters ( )

private

Definition at line 203 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    for (auto & entry : m_patternmap)
        entry.second = 0;
 
    for (unsigned lyr = 0; lyr < m_nLayers; lyr++)
        for (auto & entry : m_moduleHits[lyr])
            entry.second.reset();
}

to_string() [1/3]

std::string FPGATrackSimEtaPatternFilterTool::to_string ( const EtaPattern &  patt ) const

private

Definition at line 322 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    std::ostringstream oss;
    oss << "[";
    for (auto mod : patt) {
        oss << "[";
        oss << mod.siTech << ", " << mod.zone << ", " << mod.etaModule;
        oss << "],";
    }
    oss << "]";
    return oss.str();
}

to_string() [2/3]

std::string FPGATrackSimEtaPatternFilterTool::to_string ( const FPGATrackSimRoad &  road ) const

private

Definition at line 335 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    std::ostringstream oss;
    oss << road.getNHits()  << " : [";
    for (unsigned layer = 0; layer < m_nLayers; layer++) {
        oss << road.getNHits_layer()[layer] << ",";
    }
    oss << "]";
    return oss.str();
}

to_string() [3/3]

std::string FPGATrackSimEtaPatternFilterTool::to_string ( const std::vector< unsigned > &  v ) const

private

Definition at line 309 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    std::ostringstream oss;
    oss << "[";
    if (!v.empty())
    {
        std::copy(v.begin(), v.end()-1, std::ostream_iterator<unsigned>(oss, ", "));
        oss << v.back();
    }
    oss << "]";
    return oss.str();
}

Friends And Related Function Documentation

operator<

bool operator< ( const ModuleId &  lhs, const ModuleId &  rhs  )

friend

Definition at line 26 of file FPGATrackSimEtaPatternFilterTool.cxx.

{
    if (lhs.siTech != rhs.siTech) return lhs.siTech < rhs.siTech;
    if (lhs.zone != rhs.zone) return lhs.zone < rhs.zone;
    return lhs.etaModule < rhs.etaModule;
}

Member Data Documentation

m_doEtaPatternConsts

Gaudi::Property<bool> FPGATrackSimEtaPatternFilterTool::m_doEtaPatternConsts {this, "doEtaPatternConsts", false, "Use eta pattern IDs as part of sector definition"}

private

Definition at line 65 of file FPGATrackSimEtaPatternFilterTool.h.

m_dynamicThreshold

Gaudi::Property<bool> FPGATrackSimEtaPatternFilterTool::m_dynamicThreshold { this, "dynamicThreshold", false, "Stop lowering the threshold once matches have been found"}

private

Definition at line 66 of file FPGATrackSimEtaPatternFilterTool.h.

m_FPGATrackSimBankSvc

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

private

Definition at line 57 of file FPGATrackSimEtaPatternFilterTool.h.

m_FPGATrackSimMapping

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

private

Definition at line 56 of file FPGATrackSimEtaPatternFilterTool.h.

m_isSecondStage

Gaudi::Property<bool> FPGATrackSimEtaPatternFilterTool::m_isSecondStage {this, "isSecondStage", false, "Whether or not his this a second stage HT"}

private

Definition at line 64 of file FPGATrackSimEtaPatternFilterTool.h.

m_moduleHits

std::vector<std::map<ModuleId, ModulesToPattern> > FPGATrackSimEtaPatternFilterTool::m_moduleHits

private

Definition at line 118 of file FPGATrackSimEtaPatternFilterTool.h.

m_nLayers

unsigned FPGATrackSimEtaPatternFilterTool::m_nLayers {}

private

Definition at line 111 of file FPGATrackSimEtaPatternFilterTool.h.

m_pattern_file_path

Gaudi::Property<std::string> FPGATrackSimEtaPatternFilterTool::m_pattern_file_path {this, "EtaPatterns", "", "path to pattern file"}

private

Definition at line 62 of file FPGATrackSimEtaPatternFilterTool.h.

m_patternmap

std::map<EtaPattern, layer_bitmask_t> FPGATrackSimEtaPatternFilterTool::m_patternmap

private

Definition at line 115 of file FPGATrackSimEtaPatternFilterTool.h.

m_postfilter_roads

std::vector<FPGATrackSimRoad> FPGATrackSimEtaPatternFilterTool::m_postfilter_roads

private

Definition at line 106 of file FPGATrackSimEtaPatternFilterTool.h.

m_threshold

Gaudi::Property<unsigned> FPGATrackSimEtaPatternFilterTool::m_threshold {this, "threshold", 0, "Minimum number of hit layers to fire a road"}

private

Definition at line 63 of file FPGATrackSimEtaPatternFilterTool.h.

---

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

• FPGATrackSimEtaPatternFilterTool.h
• FPGATrackSimEtaPatternFilterTool.cxx