#include <FPGATrackSimNNPathfinderExtensionTool.h>

Inheritance diagram for FPGATrackSimNNPathfinderExtensionTool:

Collaboration diagram for FPGATrackSimNNPathfinderExtensionTool:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	extendTracks (const std::vector< std::shared_ptr< const FPGATrackSimHit > > &hits, const FPGATrackSimTrackCollection &tracks, std::vector< FPGATrackSimRoad > &roads) override
virtual StatusCode	setupSlices (FPGATrackSimLogicalEventInputHeader *slicedHitHeader) override

Private Member Functions
StatusCode	fillInputTensorForNN (miniRoad &thisRoad, std::vector< float > &inputTensorValues)
StatusCode	getPredictedHit (std::vector< float > &inputTensorValues, std::vector< float > &outputTensorValues, long &fineID)
StatusCode	getPredictedHitBatched (const std::vector< std::vector< float > > &batchInputTensors, std::vector< std::vector< float > > &batchOutputTensors, std::vector< long > &batchFineIDs)
StatusCode	addHitToRoad (miniRoad &newroad, miniRoad &currentRoad, const std::vector< std::shared_ptr< const FPGATrackSimHit > > &hits)
StatusCode	getFakeHit (miniRoad &currentRoad, std::vector< float > &predhit, const long &fineID, std::vector< std::shared_ptr< const FPGATrackSimHit > > &hits)
StatusCode	getLastLayer (miniRoad &currentRoad, unsigned &lastHitLayer, std::shared_ptr< const FPGATrackSimHit > &lastHit)
StatusCode	findHitinNextStripLayer (std::shared_ptr< const FPGATrackSimHit > hit, const std::vector< std::shared_ptr< const FPGATrackSimHit > > &hitList, std::vector< std::shared_ptr< const FPGATrackSimHit > > &hits)
void	printRoad (miniRoad &currentRoad)

Static Private Member Functions
static float	getXScale ()
static float	getYScale ()
static float	getZScale ()
static float	getRScale ()
static float	getPhiScale ()

Private Attributes
ServiceHandle< IFPGATrackSimMappingSvc >	m_FPGATrackSimMapping {this, "FPGATrackSimMappingSvc", "FPGATrackSimMappingSvc"}
ServiceHandle< ITHistSvc >	m_tHistSvc {this, "THistSvc", "THistSvc"}
ServiceHandle< IChronoStatSvc >	m_chronoSvc {this, "ChronoStatSvc", "ChronoStatSvc"}
Gaudi::Property< unsigned >	m_maxMiss { this, "threshold", 2, "Maximum number of missing hits to reject a road"}
Gaudi::Property< std::string >	m_region { this, "OutputRegion", "", "region ID"}
Gaudi::Property< std::vector< float > >	m_windowR { this, "windowR", {20.0}, "Window Size to search in for r, either pass one value for all layers or use the number of layers"}
Gaudi::Property< std::vector< float > >	m_windowZ { this, "windowZ", {20.0}, "Window Size to search in for z, either pass one value for all layers or use the number of layers"}
Gaudi::Property< std::vector< float > >	m_windowPhi { this, "windowPhi", {0.4}, "Window Size to search in for phi, either pass one value for all layers or use the number of layers"}
Gaudi::Property< std::vector< int > >	m_windowFineID { this, "windowFineID", {0}, "Fine ID indexing for windows"}
Gaudi::Property< float >	m_lowPtValueForWindowRScaling { this, "lowPtValueWindowR", -1, "Value in MeV below which we scale the r window size"}
Gaudi::Property< float >	m_lowPtWindowRScaling {this, "lowPtRScaling", 1.0, "Scaling factor for low pt in R"}
Gaudi::Property< float >	m_lowPtValueForWindowZScaling { this, "lowPtValueWindowZ", -1, "Value in MeV below which we scale the r window size"}
Gaudi::Property< float >	m_lowPtWindowZScaling {this, "lowPtZScaling", 1.0, "Scaling factor for low pt in Z"}
Gaudi::Property< float >	m_lowPtValueForWindowPhiScaling { this, "lowPtValueWindowPhi", -1, "Value in MeV below which we scale the phi window size"}
Gaudi::Property< float >	m_lowPtWindowPhiScaling {this, "lowPtPhiScaling", 1.0, "Scaling factor for low pt in Phi"}
Gaudi::Property< float >	m_missedHitRScaling {this, "missedHitRScaling", -1, "Amount to scale R window if previous hit was missed. Negative means this is disabled"}
Gaudi::Property< float >	m_missedHitZScaling {this, "missedHitZScaling", -1, "Amount to scale Z window if previous hit was missed. Negative means this is disabled"}
Gaudi::Property< float >	m_missedHitPhiScaling {this, "missedHitPhiScaling", -1, "Amount to scale Phi window if previous hit was missed. Negative means this is disabled"}
Gaudi::Property< int >	m_maxBranches { this, "maxBranches", -1, "Max number of branches before we stop, if negative this is disabled"}
Gaudi::Property< bool >	m_doOutsideIn { this, "doOutsideIn", true, "Setup the tool so it's doing outside in extrap"}
Gaudi::Property< int >	m_predictionWindowLength { this, "predictionWindowLength", 3, "Length of hits needed for prediction"}
Gaudi::Property< bool >	m_useCartesian { this, "useCartesian", true, "If true, NNs use Cartestian coordinates. If false,they use cylindrical coordiantes"}
Gaudi::Property< unsigned int >	m_batchSize { this, "batchSize", 1, "Batch size for NN inference (1 = sequential, >1 for true batching on GPU)"}
std::vector< FPGATrackSimRoad >	m_roads
unsigned	m_nLayers_1stStage = 0
unsigned	m_nLayers_2ndStage = 0
bool	m_debugEvent = false
FPGATrackSimLogicalEventInputHeader *	m_slicedHitHeader = nullptr
OnnxRuntimeBase	m_extensionVolNN
OnnxRuntimeBase	m_extensionHitNN

Detailed Description

Definition at line 128 of file FPGATrackSimNNPathfinderExtensionTool.h.

Member Function Documentation

◆ addHitToRoad()

StatusCode FPGATrackSimNNPathfinderExtensionTool::addHitToRoad	(	miniRoad &	newroad,
		miniRoad &	currentRoad,
		const std::vector< std::shared_ptr< const FPGATrackSimHit > > &	hits )

private

Definition at line 754 of file FPGATrackSimNNPathfinderExtensionTool.cxx.

{
  newroad.setHits(currentRoad.getHits());
  newroad.addHits(hits);
  return StatusCode::SUCCESS;
}

◆ extendTracks()

StatusCode FPGATrackSimNNPathfinderExtensionTool::extendTracks	(	const std::vector< std::shared_ptr< const FPGATrackSimHit > > &	hits,
		const FPGATrackSimTrackCollection &	tracks,
		std::vector< FPGATrackSimRoad > &	roads )

overridevirtual

Definition at line 160 of file FPGATrackSimNNPathfinderExtensionTool.cxx.

                                             {
 
    // Reset the internal second stage roads storage.
    roads.clear();
    m_roads.clear();
    const FPGATrackSimRegionMap* rmap_2nd = m_FPGATrackSimMapping->SubRegionMap_2nd();
 
    // Create one "tower" per slice for this event.
    // Note that there now might be only one "slice", at least for the time being.
    if (m_slicedHitHeader) {
      for (int ireg = 0; ireg < rmap_2nd->getNRegions(); ireg++) {
        FPGATrackSimTowerInputHeader tower = FPGATrackSimTowerInputHeader(ireg);
        m_slicedHitHeader->addTower(tower);
      }
    }
    
    // Build spatial index (maps) once per event
    HitSpatialIndex hitIndex;
    {
        Athena::Chrono chronoBuildIndex("NNPathfinder:BuildSpatialIndex", m_chronoSvc.get());
        hitIndex.build(hits);
    }
    
    if(m_debugEvent) ATH_MSG_DEBUG("Got: "<<tracks.size()<<" tracks to extrapolate");
    // Now, loop over the tracks.
    for (const FPGATrackSimTrack& track : tracks) {
        Athena::Chrono chronoTrackLoop("NNPathfinder:TrackLoop", m_chronoSvc.get());
        if(m_debugEvent) ATH_MSG_DEBUG("\033[1;31m-------------------------- extraploating Track ------------------ \033[0m");
        if (track.passedOR() == 0) {
            continue;
        }
        const auto& hitsOnTrack = track.getFPGATrackSimHitPtrs();
        miniRoad road;
        float pt = track.getPt();
 
        for (const auto& hit_ptr : hitsOnTrack) {
            if (!hit_ptr) {
                ATH_MSG_ERROR("Null hit pointer in track");
                return StatusCode::FAILURE;
            }
            road.addHit(hit_ptr); // shared_ptr already points to active hit
        }
 
        if (m_debugEvent) {
            ATH_MSG_DEBUG("-----------------Hits in event");
            for (const auto& hit : hits) {
                ATH_MSG_DEBUG("Hit " << " X: " << hit->getX() << " Y: " << hit->getY() << " Z: " << hit->getZ() << " R: " << hit->getR() << "phi = " << hit->getGPhi() << " hitType: " << hit->getHitType() << " getDetType: " << hit->getDetType());
            }
        }
        // Using deque instead of vector for O(1) pop_front since we need operate only the first road each iteration
        std::deque<miniRoad> roadsToExtrapolate;
        roadsToExtrapolate.push_back(std::move(road));
 
        std::vector<miniRoad> completedRoads;
 
        int count = 0;
    // FIXED: Add maximum iteration limit to prevent infinite loops
        const int MAX_ROADS = 10000;
        
        // Batching structures
        std::vector<std::pair<miniRoad, std::vector<float>>> roadsAwaitingInference; // pairs of (road, input_tensor)
        
    while(!roadsToExtrapolate.empty() && count < MAX_ROADS ) {
      miniRoad currentRoad = std::move(roadsToExtrapolate.front());
 
            // Erase this road from the deque
            roadsToExtrapolate.pop_front();
            count ++;
            if(m_debugEvent) {
                ATH_MSG_DEBUG("\033[1;31m-------------------------- extraploating road "<< count << "------------------ \033[0m");
                printRoad(currentRoad);
            }
            // Check exit condition
            if (currentRoad.getNHits() >= (m_nLayers_1stStage+m_nLayers_2ndStage))
            {
                completedRoads.push_back(std::move(currentRoad));
                continue; // this one is done
            }
            
            // Prepare input tensor for NN
            std::vector<float> inputTensorValues;
            if (!fillInputTensorForNN(currentRoad, inputTensorValues)) {
                ATH_MSG_WARNING("Failed to create input tensor for this road");
                continue;
            }
            
            // Collect road for batching
            roadsAwaitingInference.push_back(std::make_pair(std::move(currentRoad), inputTensorValues));
            
            // When batch is full OR queue is empty, process batch
            bool processBatch = (roadsAwaitingInference.size() >= (size_t)m_batchSize) || roadsToExtrapolate.empty();
            
            if (processBatch && !roadsAwaitingInference.empty()) {
                // Prepare batched inputs
                std::vector<std::vector<float>> batchInputTensors;
                std::vector<std::pair<miniRoad, std::vector<float>>> roadBatch = std::move(roadsAwaitingInference);
                roadsAwaitingInference.clear();
                
                for (const auto& [road, tensor] : roadBatch) {
                    batchInputTensors.push_back(tensor);
                }
                
                // Run batched inference
                std::vector<std::vector<float>> batchOutputTensors;
                std::vector<long> batchFineIDs;
                {
                    Athena::Chrono chronoNN("NNPathfinder:NNInference", m_chronoSvc.get());
                    if (getPredictedHitBatched(batchInputTensors, batchOutputTensors, batchFineIDs) != StatusCode::SUCCESS) {
                        ATH_MSG_WARNING("Batched NN inference failed");
                        continue;
                    }
                }
                
                // Process each result in the batch
                for (size_t batchIdx = 0; batchIdx < roadBatch.size(); ++batchIdx) {
                    miniRoad processRoad = std::move(roadBatch[batchIdx].first);
                    std::vector<float> predhit = batchOutputTensors[batchIdx];
                    long fineID = batchFineIDs[batchIdx];
                    
                    // Check if exit conditions are met
                    if (m_doOutsideIn) {
                        // Make sure we are not predicting inside the inner most layer (x and y < 25, or r < 25)
                        // If we are, road is done
                        if ((m_useCartesian && (abs(predhit[0]) < 25 && abs(predhit[1]) < 25)) ||
                            (!m_useCartesian && abs(predhit[0]) < 25))
                        {
                            completedRoads.push_back(std::move(processRoad));
                            continue;
                        }
                    }
                    else {
                        // Make sure we are not predicting outside the outer most layer       
                        // if we are, road is done
                        double radius = std::sqrt(predhit[0] * predhit[0] + predhit[1] * predhit[1]);
                        if ((m_useCartesian && (abs(predhit[0]) > 1024 || abs(predhit[1]) > 1024 || radius > 1024 || abs(predhit[2]) > 3000)) ||
                            (!m_useCartesian && (abs(predhit[0]) > 1024 || abs(predhit[2]) > 3000))) {
                            completedRoads.push_back(std::move(processRoad));
                            continue;
                        }
                    }
                    if(m_debugEvent) {
                        ATH_MSG_DEBUG("Predicted hit at: " << predhit[0] << " " << predhit[1] << " " << predhit[2]);
                    }
 
                    // Now search for the hits
                    bool foundhitForRoad = false;
                    if(fineID == 215){
                        ATH_MSG_DEBUG("Stopping condition reached");
                        completedRoads.push_back(std::move(processRoad));
                        continue;
                    }
 
                    // Get the last layer and hit in the road
                    unsigned lastLayerInRoad = 0;
                    std::shared_ptr<const FPGATrackSimHit> lastHit;
                    if(!getLastLayer(processRoad, lastLayerInRoad, lastHit) or !lastHit) {
                        ATH_MSG_WARNING("Failed to find last layer this road");
                        continue;
                    }
                    unsigned layer = lastLayerInRoad+1; // the layer we're looking to find
                    bool lastHitWasReal = lastHit->isReal();
                    float lastHitR = lastHit->getR();
                    if(layer >= (m_nLayers_1stStage + m_nLayers_2ndStage)) {
                        completedRoads.push_back(std::move(processRoad));
                        continue;
                    }
                    unsigned int hitsInWindow = 0;
 
                    // Cache predicted values and window parameters once per road, not per hit
                    const double predr = (m_useCartesian ? sqrt(predhit[0] * predhit[0] + predhit[1] * predhit[1]) : predhit[0]);
                    const double predphi = predhit[1];
                    const double predz = predhit[2];
                    
                    // Calculate window parameters once
                    double windowR = m_windowR[0];
                    double windowPhi = m_windowPhi[0];
                    double windowZ = m_windowZ[0];
                    int fineID_index = 0;
                    
                    if (m_windowZ.size() > 1 || m_windowR.size() > 1 || m_windowPhi.size() > 1) {
                        auto fineID_it = std::find(m_windowFineID.begin(), m_windowFineID.end(), fineID);
                        if (fineID_it == m_windowFineID.end()) {
                            ATH_MSG_DEBUG("No windows for predicted fineID " << fineID << ", using maximum in provided list instead!");
                            fineID_index = -1;
                        }
                        else {
                            fineID_index = fineID_it - m_windowFineID.begin();
                        }
                    }
            if (m_windowR.size() > 1) {
                windowR = (fineID_index == -1) ? 
                    *std::max_element(m_windowR.begin(), m_windowR.end()) : 
                    m_windowR[fineID_index];
            }
            if (m_windowZ.size() > 1) {
                windowZ = (fineID_index == -1) ? 
                    *std::max_element(m_windowZ.begin(), m_windowZ.end()) : 
                    m_windowZ[fineID_index];
            }
            if (m_windowPhi.size() > 1) {
                windowPhi = (fineID_index == -1) ? 
                    *std::max_element(m_windowPhi.begin(), m_windowPhi.end()) : 
                    m_windowPhi[fineID_index];
            }
            
            // Apply scaling factors
            if (m_missedHitRScaling > 0 && !lastHitWasReal) windowR *= m_missedHitRScaling;
            if (m_missedHitZScaling > 0 && !lastHitWasReal) windowZ *= m_missedHitZScaling;
            if (m_missedHitPhiScaling > 0 && !lastHitWasReal) windowPhi *= m_missedHitPhiScaling;
            if (pt < m_lowPtValueForWindowRScaling.value()) windowR *= m_lowPtWindowRScaling.value();
            if (pt < m_lowPtValueForWindowZScaling.value()) windowZ *= m_lowPtWindowZScaling.value();
            if (pt < m_lowPtValueForWindowPhiScaling.value()) windowPhi *= m_lowPtWindowPhiScaling.value();
 
            // List of all the hits, with their distances to the predicted point
            std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>> listofHitsFound;
 
            {
            Athena::Chrono chronoHitSearch("NNPathfinder:HitSearchLoop", m_chronoSvc.get());
            
            // Use spatial index (HitSpatialIndex) to get only candidate hits with matching fineID
            const auto* candidateHits = hitIndex.getHits(fineID);
            if (candidateHits) {
                listofHitsFound.reserve(candidateHits->size());
 
                for (const auto& hit_ptr : *candidateHits) {
                    const auto& hit = *hit_ptr;
                    // Apply direction filter
                    const float hitr = hit.getR();
                    if (m_doOutsideIn && hitr > lastHitR) continue;
                    if (!m_doOutsideIn && hitr < lastHitR) continue;
 
                    if(m_debugEvent) {
                        ATH_MSG_DEBUG("In the hit loop hit at x: " << hit.getX() << " y " << hit.getY() << " z " << hit.getZ() << " phi " << hit.getGPhi());
                    }
 
                    // Check if hit is within window
                    const double hitz = hit.getZ();
                    const double hitphi = hit.getGPhi();
 
                    const double dr = abs(hitr - predr);
                    const double dz = abs(hitz - predz);
                    double dphi = abs(hitphi - predphi);
                    while (dphi > pi) dphi -= pi;
 
                    const bool inWindow = (m_useCartesian && dr < windowR && dz < windowZ) ||
                                          (!m_useCartesian && dphi < windowPhi && dz < windowZ && dr < windowR);
 
                    if (!inWindow) continue;
 
                    // Only create shared_ptr when hit passes all filters
                    std::vector<std::shared_ptr<const FPGATrackSimHit>> theseHits{ hit_ptr };
                    hitsInWindow = hitsInWindow + 1;
 
                    // Handle strip space points
                    if(hit.isStrip()) {
                        if (hit.getHitType() == HitType::spacepoint) {
                            // Use spatial index for strip matching
                            const float EPSILON = 0.00001f;
                            const float searchX = hit.getX();
                            const float searchY = hit.getY();
                            const float searchZ = hit.getZ();
                            const auto searchHash = hit.getIdentifierHash();
                            bool found = false;
 
                            const auto* coordCandidates = hitIndex.getHitsByCoord(searchX, searchY, searchZ);
                            if (coordCandidates) {
                                for (const auto& candidateHitPtr : *coordCandidates) {
                                    const auto& candidateHit = *candidateHitPtr;
                                    if (candidateHit.getIdentifierHash() != searchHash &&
                                        abs(candidateHit.getX() - searchX) < EPSILON &&
                                        abs(candidateHit.getY() - searchY) < EPSILON &&
                                        abs(candidateHit.getZ() - searchZ) < EPSILON) {
                                        theseHits.push_back(candidateHitPtr);
                                        found = true;
                                        break;
                                    }
                                }
                            }
                            if (!found) {
                                ATH_MSG_WARNING("For a SP in layer " << layer << " Couldn't find a matching strip SP");
                            }
                        }
                        else {
                            std::shared_ptr<FPGATrackSimHit> guessedSecondHitPtr = std::make_shared<FPGATrackSimHit>();
                            guessedSecondHitPtr->setX(0);
                            guessedSecondHitPtr->setY(0);
                            guessedSecondHitPtr->setZ(0);
                            guessedSecondHitPtr->setPhysLayer(lastHit->getPhysLayer(true)+1);
                            guessedSecondHitPtr->setHitType(HitType::undefined);
                            if(isFineIDInStrip(fineID))  guessedSecondHitPtr->setDetType(SiliconTech::strip);
                            else  guessedSecondHitPtr->setDetType(SiliconTech::pixel);
 
                            theseHits.push_back(guessedSecondHitPtr);
                        }
                    }
                    // Store the hits for now
                    listofHitsFound.push_back(std::move(theseHits));
                }
            }
            } // end HitSearchLoop timing
 
            {
            Athena::Chrono chronoSort("NNPathfinder:HitSorting", m_chronoSvc.get());
            
            // Use partial_sort instead of sort since we only need the top N hits
            const size_t nToSort = (m_maxBranches.value() >= 0) ? 
                std::min(static_cast<size_t>(m_maxBranches.value()), listofHitsFound.size()) : 
                listofHitsFound.size();
            
            // Sort the hit by the distance
            if (m_useCartesian) {
                auto comparatorFunc = [&](const auto& a, const auto& b) {
                    return cartesianComparator(a, b, predr, predz);
                };
                if (nToSort < listofHitsFound.size()) {
                    std::partial_sort(listofHitsFound.begin(),
                                      listofHitsFound.begin() + nToSort,
                                      listofHitsFound.end(),
                                      comparatorFunc);
                } else {
                    std::sort(listofHitsFound.begin(), listofHitsFound.end(), comparatorFunc);
                }
            }
            else {
                const double zScale = getZScale();
                const double phiScale = getPhiScale();
                const double rScale = getRScale();
                const double zScale2 = zScale * zScale;
                const double phiScale2 = phiScale * phiScale;
                const double rScale2 = rScale * rScale;
 
                auto comparatorFunc = [&](const auto& a, const auto& b) {
                    return polarComparator(a, b, predr, predphi, predz, zScale2, phiScale2, rScale2);
                };
                if (nToSort < listofHitsFound.size()) {
                    std::partial_sort(listofHitsFound.begin(),
                                      listofHitsFound.begin() + nToSort,
                                      listofHitsFound.end(),
                                      comparatorFunc);
                } else {
                    std::sort(listofHitsFound.begin(), listofHitsFound.end(), comparatorFunc);
                }
            }
            } // end HitSorting timing
 
            // Select the top N hits
            std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>> cleanHitsToGrow;
 
            // If max branches are limited, pick only the top N from the list of hits found at each level
            if (m_maxBranches.value() >= 0) {
                int nHitsToChoose = std::min(int(m_maxBranches.value()), int(listofHitsFound.size()));
                cleanHitsToGrow.reserve(nHitsToChoose);
                std::copy(listofHitsFound.begin(), listofHitsFound.begin() + nHitsToChoose, std::back_inserter(cleanHitsToGrow));
            }
            else {
                cleanHitsToGrow = std::move(listofHitsFound);
            }
 
            {
            Athena::Chrono chronoRoadBuilding("NNPathfinder:RoadBuilding", m_chronoSvc.get());
            for (auto& hitsFound: cleanHitsToGrow) {
 
                // We got a hit, lets make a road
                miniRoad newRoad;
                if(!addHitToRoad(newRoad, processRoad, std::move(hitsFound))) {
                    ATH_MSG_WARNING("Failed to make a new road");
                    continue;
                }
                roadsToExtrapolate.push_back(newRoad);
                foundhitForRoad = true;
                if(m_debugEvent) {
                    ATH_MSG_DEBUG("------ road grown with hit from layer "<<layer<<" to");
                    printRoad(newRoad);
                }
            }
            // If the hit wasn't found, push a fake hit
            if (!foundhitForRoad) {
                // did not find a hit to extrapolate to, check if we need to delete this road. if not, add a guessed hit if still useful
                if (processRoad.getNWCLayers() >= m_maxMiss) {
                    // we don't want this road, so we continue
                    continue;
                }
                else {
                    std::vector<std::shared_ptr<const FPGATrackSimHit>> theseHits;
                    // first make the fake hit that we will add
                    if (!getFakeHit(processRoad, predhit, fineID, theseHits)) {
                        ATH_MSG_WARNING("Failed adding a guessed hit in extrapolation");
                        continue;
                    }
 
                    if((isFineIDInPixel(fineID) && theseHits.size() != 1) || (isFineIDInStrip(fineID) && theseHits.size() != 2)) {
                        continue;
                    }
                    // add the hit to the road
                    miniRoad newroad;
                    if (!addHitToRoad(newroad, processRoad, std::move(theseHits))) {
                        ATH_MSG_WARNING("Failed making a new road with fake hit");
                        continue;
                    }
                    roadsToExtrapolate.push_back(std::move(newroad));
                }
            }
            } // end RoadBuilding timing
                } // end batch processing for individual road
            } // end batch inference processing
        } // end while loop for all roads
        {
        Athena::Chrono chronoRoadConversion("NNPathfinder:RoadConversion", m_chronoSvc.get());
        for (const auto &miniroad : completedRoads) {
            FPGATrackSimRoad road;
            road.setWCLayers(miniroad.getWCLayers());
            road.setHitLayers(miniroad.getHitLayers());
            road.setRoadID(m_roads.size() - 1);
            // Set the "Hough x" and "Hough y" using the track parameters.
            road.setX(track.getPhi());
            road.setY(track.getQOverPt());
            road.setXBin(track.getHoughXBin());
            road.setYBin(track.getHoughYBin());
            road.setSubRegion(track.getSubRegion());
 
            // just force the right number of layers now, in case we find fewer than expected (needed downstream)
            std::vector<std::vector<std::shared_ptr<const FPGATrackSimHit>>> roadhits = miniroad.getVecHits();
            unsigned nexpected = m_nLayers_1stStage+m_nLayers_2ndStage;
            if (roadhits.size() > nexpected) { // cut off the last ones
                roadhits.resize(nexpected);
            }
            else if (roadhits.size() < nexpected) { // fill with missing hits
                for (unsigned layer = roadhits.size(); layer < nexpected; layer++) {
                    std::shared_ptr<FPGATrackSimHit> emptyHitPtr = std::make_shared<FPGATrackSimHit>();
                    emptyHitPtr->setX(0);
                    emptyHitPtr->setY(0);
                    emptyHitPtr->setZ(0);
                    emptyHitPtr->setLayer(layer);
                    emptyHitPtr->setHitType(HitType::wildcard);
                   
                    roadhits.emplace_back(1,emptyHitPtr);
                    layer_bitmask_t wclayers = road.getWCLayers();
                    wclayers |= (1 << layer);
                    road.setWCLayers(wclayers);
                }
            }
            road.setHits(std::move(roadhits));
 
            m_roads.push_back(std::move(road));
        }
        } // end RoadConversion timing
    }
    // Copy the roads we found into the output argument and return success.
    roads.reserve(m_roads.size());
    for (FPGATrackSimRoad & r : m_roads)
    {
        if (r.getNWCLayers() >= m_maxMiss) continue; // extra check on this
        roads.emplace_back(r);
    }
    ATH_MSG_DEBUG("Found " << roads.size() << " new roads in second stage.");
 
    return StatusCode::SUCCESS;
}

◆ fillInputTensorForNN()

StatusCode FPGATrackSimNNPathfinderExtensionTool::fillInputTensorForNN	(	miniRoad &	thisRoad,
		std::vector< float > &	inputTensorValues )

private

Definition at line 621 of file FPGATrackSimNNPathfinderExtensionTool.cxx.

{
    std::vector<std::shared_ptr<const FPGATrackSimHit>> hitsR;
 
    std::vector<std::shared_ptr<const FPGATrackSimHit>> hits = thisroad.getHits();
 
 
    for (unsigned ihit = 0; ihit < hits.size(); ihit++) {
      if (ihit < m_nLayers_1stStage && !(hits[ihit]->isReal())) continue; // skip guessed hits for the 1st stage
       hitsR.push_back(hits[ihit]);
    }
    // Sort in increasing 3D distance.
    std::sort(hitsR.begin(), hitsR.end(), [](auto& a, auto& b){
        double dist_a = std::hypot(a->getX(), a->getY(), a->getZ());
        double dist_b = std::hypot(b->getX(), b->getY(), b->getZ());
        return dist_a < dist_b;
    });
 
    if(m_debugEvent) ATH_MSG_DEBUG("hitsR");
    for (const auto& thit : hitsR)
    {
        if (m_debugEvent) ATH_MSG_DEBUG(thit->getX() << " " << thit->getY() << " " << thit->getZ() << " and phi = " << thit->getGPhi());
    }
 
    // Remove all the duplicate space points
    std::vector<std::shared_ptr<const FPGATrackSimHit>> cleanHits;
    bool skipHit = false;
    for (auto thit : hitsR)
    {
        if(skipHit)
        {
            skipHit = false;
            continue;
        }
        if (thit->isPixel())
        {
            cleanHits.push_back(std::move(thit));
        }
        else if (thit->isStrip() && (thit->getHitType() == HitType::spacepoint))
        {
            // This is a proper strips SP, push the first hit back and skip the next one since its a duplicate
            cleanHits.push_back(std::move(thit));
            skipHit = true;
        }
        else if (thit->isStrip() && (thit->getHitType() == HitType::guessed))
        {
            // this is a guessed strip SP, push the first hit back and skip the next one since its a duplicate
            cleanHits.push_back(std::move(thit));
            skipHit = true;
        }
        else if (thit->isStrip() && (thit->getHitType() == HitType::undefined))
        {
            // this is a fake hit, inserted for a unpaired SP, continue
            continue;
        }
        else if (thit->isStrip() && thit->isReal())
        {
            // What is left here is a unpaired hit, push it back
            cleanHits.push_back(std::move(thit));
        }
        else
        {
            ATH_MSG_WARNING("No clue how to deal with this hit in the NN predicition ");
            continue;
        }
    }
 
    // Reverse the hits as we changed the ordering before
    if(!m_doOutsideIn)
    {
        std::reverse(cleanHits.begin(), cleanHits.end());
    }
 
    // Select the top N hits
    std::vector<std::shared_ptr<const FPGATrackSimHit>> hitsToEncode;
    std::copy(cleanHits.begin(), cleanHits.begin() + m_predictionWindowLength, std::back_inserter(hitsToEncode));
 
    if(m_debugEvent) ATH_MSG_DEBUG("Clean hits");
    for (const auto& thit : cleanHits)
    {
        if (m_debugEvent) ATH_MSG_DEBUG(thit->getX() << " " << thit->getY() << " " << thit->getZ() << " " << thit->isStrip() << " and gphi = " << thit->getGPhi());
    }
 
    // Reverse this vector so we can encode it the format as expected from the NN
    std::reverse(hitsToEncode.begin(), hitsToEncode.end());
 
    if (m_debugEvent) ATH_MSG_DEBUG("Input for NN prediction");
    for (const auto& thit : hitsToEncode)
    {
        if (m_useCartesian) {
            inputTensorValues.push_back(thit->getX() / getXScale());
            inputTensorValues.push_back(thit->getY() / getYScale());
            inputTensorValues.push_back(thit->getZ() / getZScale());
        }
        else {
            inputTensorValues.push_back(thit->getR() / getRScale());
            inputTensorValues.push_back(thit->getGPhi() / getPhiScale());
            inputTensorValues.push_back(thit->getZ() / getZScale());
        }
 
        if (m_debugEvent) ATH_MSG_DEBUG(thit->getX() << " " << thit->getY() << " " << thit->getZ() << " and gphi = " << thit->getGPhi());
    }
 
    return StatusCode::SUCCESS;
 
}

◆ findHitinNextStripLayer()

StatusCode FPGATrackSimNNPathfinderExtensionTool::findHitinNextStripLayer	(	std::shared_ptr< const FPGATrackSimHit >	hit,
		const std::vector< std::shared_ptr< const FPGATrackSimHit > > &	hitList,
		std::vector< std::shared_ptr< const FPGATrackSimHit > > &	hits )

private

◆ getFakeHit()

StatusCode FPGATrackSimNNPathfinderExtensionTool::getFakeHit	(	miniRoad &	currentRoad,
		std::vector< float > &	predhit,
		const long &	fineID,
		std::vector< std::shared_ptr< const FPGATrackSimHit > > &	hits )

private

Definition at line 761 of file FPGATrackSimNNPathfinderExtensionTool.cxx.

                                                                                                                                                                                        {
 
  unsigned guessedLayer(0);
 
    std::shared_ptr<FPGATrackSimHit> guessedHitPtr = std::make_shared<FPGATrackSimHit>();
    if (m_useCartesian) {
      guessedHitPtr->setX(predhit[0]);
      guessedHitPtr->setY(predhit[1]);
      guessedHitPtr->setZ(predhit[2]);
    }
    else {
      double r = predhit[0];
      double phi = predhit[1];
      guessedHitPtr->setX(r*cos(phi));
      guessedHitPtr->setY(r*sin(phi));
      guessedHitPtr->setZ(predhit[2]);
    }
     
 
    if (m_doOutsideIn) { // outside in
      // TODO
    }
    else { // nope, inside out
      guessedLayer = currentRoad.getNHits();
    }
 
    guessedHitPtr->setLayer(guessedLayer);
    guessedHitPtr->setHitType(HitType::guessed);
 
    if(isFineIDInStrip(fineID))  {
      guessedHitPtr->setDetType(SiliconTech::strip);
      guessedHitPtr->setPhysLayer(0); // it is just to set the side, it's not actually 0
    }
    else  guessedHitPtr->setDetType(SiliconTech::pixel);
 
 
    // Make sure that the hit is inside the boundaries of the layers
    if(guessedLayer < (m_nLayers_1stStage + m_nLayers_2ndStage ))
    {
        hits.push_back(guessedHitPtr);
    }
    // if in strips, add the second hit into the list
    if(isFineIDInStrip(fineID))
    {
        std::shared_ptr<FPGATrackSimHit> guessedSecondHitPtr = std::make_shared<FPGATrackSimHit>();
        guessedSecondHitPtr->setX(0);
        guessedSecondHitPtr->setY(0);
        guessedSecondHitPtr->setZ(0);
        guessedSecondHitPtr->setLayer( guessedLayer + 1 );
        guessedSecondHitPtr->setHitType(HitType::guessed);
 
        guessedSecondHitPtr->setDetType(SiliconTech::strip);
    guessedHitPtr->setPhysLayer(1); // it is just to set the side, it's not actually 1
        // Make sure that the hit is inside the boundaries of the layers
        if((guessedLayer + 1) < (m_nLayers_1stStage + m_nLayers_2ndStage ))
        {
            hits.push_back(guessedSecondHitPtr);
        }
    }
 
 
 
    return StatusCode::SUCCESS;
 
}

◆ getLastLayer()

StatusCode FPGATrackSimNNPathfinderExtensionTool::getLastLayer	(	miniRoad &	currentRoad,
		unsigned &	lastHitLayer,
		std::shared_ptr< const FPGATrackSimHit > &	lastHit )

private

Definition at line 862 of file FPGATrackSimNNPathfinderExtensionTool.cxx.

{
    lastHitLayer = currentRoad.getNHits()-1;
    lastHit = currentRoad.getHit(lastHitLayer);
    return StatusCode::SUCCESS;
 
}

◆ getPhiScale()

float FPGATrackSimNNPathfinderExtensionTool::getPhiScale ( )

inlinestaticprivate

Definition at line 188 of file FPGATrackSimNNPathfinderExtensionTool.h.

188{return 3.15;};

◆ getPredictedHit()

StatusCode FPGATrackSimNNPathfinderExtensionTool::getPredictedHit	(	std::vector< float > &	inputTensorValues,
		std::vector< float > &	outputTensorValues,
		long &	fineID )

private

Definition at line 729 of file FPGATrackSimNNPathfinderExtensionTool.cxx.

{
    std::vector<float> NNVoloutput = m_extensionVolNN.runONNXInference(inputTensorValues);
    fineID = std::distance(NNVoloutput.begin(),std::max_element(NNVoloutput.begin(), NNVoloutput.end()));
    // Insert the output for the second stage NN
    inputTensorValues.insert(inputTensorValues.end(), NNVoloutput.begin(), NNVoloutput.end()); //now we append the first NN to the list of coordinates
 
    // use the above to predict the next hit position
    outputTensorValues = m_extensionHitNN.runONNXInference(inputTensorValues);
 
    // now scale back
    if (m_useCartesian) {
      outputTensorValues[0] *= getXScale();
      outputTensorValues[1] *= getYScale();
      outputTensorValues[2] *= getZScale();
    }
    else {
      outputTensorValues[0] *= getRScale();
      outputTensorValues[1] *= getPhiScale();
      outputTensorValues[2] *= getZScale();
    }
 
    return StatusCode::SUCCESS;
}

◆ getPredictedHitBatched()

StatusCode FPGATrackSimNNPathfinderExtensionTool::getPredictedHitBatched	(	const std::vector< std::vector< float > > &	batchInputTensors,
		std::vector< std::vector< float > > &	batchOutputTensors,
		std::vector< long > &	batchFineIDs )

private

Definition at line 870 of file FPGATrackSimNNPathfinderExtensionTool.cxx.

{
    if (batchInputTensors.empty()) {
        return StatusCode::SUCCESS;
    }
 
    size_t batchSize = batchInputTensors.size();
    size_t featureSize = batchInputTensors[0].size();
    
    // Convert to Eigen matrix format for proper batch dimension handling
    // Rows = batch_size, Cols = features
    NetworkBatchInput volInputMatrix(batchSize, featureSize);
    for (size_t i = 0; i < batchSize; ++i) {
        for (size_t j = 0; j < featureSize; ++j) {
            volInputMatrix(i, j) = batchInputTensors[i][j];
        }
    }
 
    // Run volume NN in batch using proper tensor format
    auto volNNBatchedOutput = m_extensionVolNN.runONNXInference(volInputMatrix);
    
    // Extract fineIDs from volume NN output (one per sample in batch)
    // Output shape: [batch_size, num_classes]
    batchFineIDs.reserve(batchSize);
    
    for (size_t i = 0; i < volNNBatchedOutput.size(); ++i) {
        const auto& output = volNNBatchedOutput[i];
        auto maxIdx = std::distance(output.begin(), std::max_element(output.begin(), output.end()));
        batchFineIDs.push_back(maxIdx);
    }
 
    // Prepare input for hit NN: concatenate original inputs with volume NN outputs
    // Hit NN takes [original_features, volume_nn_output] as input
    size_t numClasses = volNNBatchedOutput[0].size();
    NetworkBatchInput hitInputMatrix(batchSize, featureSize + numClasses);
    
    for (size_t i = 0; i < batchSize; ++i) {
        // First part: original input features
        for (size_t j = 0; j < featureSize; ++j) {
            hitInputMatrix(i, j) = batchInputTensors[i][j];
        }
        // Second part: volume NN outputs
        for (size_t j = 0; j < numClasses; ++j) {
            hitInputMatrix(i, featureSize + j) = volNNBatchedOutput[i][j];
        }
    }
 
    // Run hit NN in batch using proper tensor format
    auto hitNNBatchedOutput = m_extensionHitNN.runONNXInference(hitInputMatrix);
 
    batchOutputTensors.reserve(batchSize);
    
    // Output (already in correct format: vector<vector<float>>) with batch_size samples
    for (size_t i = 0; i < hitNNBatchedOutput.size(); ++i) {
        std::vector<float> output = hitNNBatchedOutput[i];
        
        // Scale back to original units
        if (m_useCartesian) {
            output[0] *= getXScale();
            output[1] *= getYScale();
            output[2] *= getZScale();
        } else {
            output[0] *= getRScale();
            output[1] *= getPhiScale();
            output[2] *= getZScale();
        }
        
        batchOutputTensors.push_back(std::move(output));
    }
 
    return StatusCode::SUCCESS;
}

◆ getRScale()

float FPGATrackSimNNPathfinderExtensionTool::getRScale ( )

inlinestaticprivate

Definition at line 187 of file FPGATrackSimNNPathfinderExtensionTool.h.

187{return 1015.;};

◆ getXScale()

float FPGATrackSimNNPathfinderExtensionTool::getXScale ( )

inlinestaticprivate

Definition at line 184 of file FPGATrackSimNNPathfinderExtensionTool.h.

184{ return 1015.;};

◆ getYScale()

float FPGATrackSimNNPathfinderExtensionTool::getYScale ( )

inlinestaticprivate

Definition at line 185 of file FPGATrackSimNNPathfinderExtensionTool.h.

185{ return 1015.;};

◆ getZScale()

float FPGATrackSimNNPathfinderExtensionTool::getZScale ( )

inlinestaticprivate

Definition at line 186 of file FPGATrackSimNNPathfinderExtensionTool.h.

186{ return 3000.;};

◆ initialize()

StatusCode FPGATrackSimNNPathfinderExtensionTool::initialize ( )

overridevirtual

Definition at line 118 of file FPGATrackSimNNPathfinderExtensionTool.cxx.

                                                             {
 
    // Retrieve the mapping service.
    ATH_CHECK(m_FPGATrackSimMapping.retrieve());
 
    // hard code this for now but we may chance in the future
    m_nLayers_1stStage = 5;
    m_nLayers_2ndStage = 8;
 
    if (m_windowR.size() != 1 && m_windowR.size() != m_windowFineID.size()) {
      ATH_MSG_ERROR("Window r size = " << m_windowR << " is not equal to 1 (for all layers) and not equal to " << m_windowFineID.size());
      return StatusCode::FAILURE;
    }
 
    if (m_windowPhi.size() != 1 && m_windowPhi.size() != m_windowFineID.size()) {
      ATH_MSG_ERROR("Window phi size = " << m_windowPhi << " is not equal to 1 (for all layers) and not equal to " << m_windowFineID.size());
      return StatusCode::FAILURE;
    }    
 
    if (m_windowZ.size() != 1 && m_windowZ.size() != m_windowFineID.size()) {
      ATH_MSG_ERROR("Window z size = " << m_windowZ << " is not equal to 1 (for all layers) and not equal to " << m_windowFineID.size());
      return StatusCode::FAILURE;
    }
 
    if (m_FPGATrackSimMapping->getExtensionNNVolMapString() != "" && m_FPGATrackSimMapping->getExtensionNNHitMapString() != "") {
        ATH_MSG_INFO("Initializing extension hit NN with string = " << m_FPGATrackSimMapping->getExtensionNNHitMapString());
        m_extensionHitNN.initialize(m_FPGATrackSimMapping->getExtensionNNHitMapString());
        ATH_MSG_INFO("Initializing volume NN with string = " << m_FPGATrackSimMapping->getExtensionNNVolMapString());
        m_extensionVolNN.initialize(m_FPGATrackSimMapping->getExtensionNNVolMapString());
    }
    else {
        ATH_MSG_ERROR("Path to NN-based track extension ONNX file is empty! If you want to run this pipeline, you need to provide an input file.");
        return StatusCode::FAILURE;
    }
 
    ATH_CHECK(m_tHistSvc.retrieve());
    ATH_CHECK(m_chronoSvc.retrieve());
 
    return StatusCode::SUCCESS;
}

◆ printRoad()

void FPGATrackSimNNPathfinderExtensionTool::printRoad ( miniRoad & currentRoad )

private

Definition at line 827 of file FPGATrackSimNNPathfinderExtensionTool.cxx.

{
    if (!m_debugEvent) return;
 
    // print this road
    if (m_debugEvent)
    {
        std::vector<std::shared_ptr<const FPGATrackSimHit>> hitsR;
        for (const auto& hit : currentRoad.getHits()) {
            hitsR.push_back(hit);
        }
 
        // If outside in, sort in increasing R, otherwise, decreasing R
        if (m_doOutsideIn)
        {
            std::sort(hitsR.begin(), hitsR.end(), [](const auto& a, const auto& b) {
                if (a->getR() == b->getR()) return a->getLayer() < b->getLayer();
                return a->getR() < b->getR();
                });
        }
        else
        {
            std::sort(hitsR.begin(), hitsR.end(), [](const auto& a, const auto& b) {
                return a->getR() > b->getR();
                });
        }
 
        for (unsigned long i = 0; i < hitsR.size(); i++)
        {
            ATH_MSG_DEBUG("Hit i " << i << " X: " << hitsR[i]->getX() << " Y: " << hitsR[i]->getY() << " Z: " << hitsR[i]->getZ() << " R: " << hitsR[i]->getR() << " hitType: " << hitsR[i]->getHitType() << " getDetType: " << hitsR[i]->getDetType() << "phi = " << hitsR[i]->getGPhi());
        }
    }
 
}

◆ setupSlices()

virtual StatusCode FPGATrackSimNNPathfinderExtensionTool::setupSlices ( FPGATrackSimLogicalEventInputHeader * slicedHitHeader )

inlineoverridevirtual

Definition at line 141 of file FPGATrackSimNNPathfinderExtensionTool.h.

                                                                                                      {
          m_slicedHitHeader = slicedHitHeader;
          return StatusCode::SUCCESS;
        };

Member Data Documentation

◆ m_batchSize

Gaudi::Property<unsigned int> FPGATrackSimNNPathfinderExtensionTool::m_batchSize { this, "batchSize", 1, "Batch size for NN inference (1 = sequential, >1 for true batching on GPU)"}

private

Definition at line 177 of file FPGATrackSimNNPathfinderExtensionTool.h.

177{ this, "batchSize", 1, "Batch size for NN inference (1 = sequential, >1 for true batching on GPU)"};

◆ m_chronoSvc

ServiceHandle<IChronoStatSvc> FPGATrackSimNNPathfinderExtensionTool::m_chronoSvc {this, "ChronoStatSvc", "ChronoStatSvc"}

private

Definition at line 150 of file FPGATrackSimNNPathfinderExtensionTool.h.

150{this, "ChronoStatSvc", "ChronoStatSvc"};

◆ m_debugEvent

bool FPGATrackSimNNPathfinderExtensionTool::m_debugEvent = false

private

Definition at line 190 of file FPGATrackSimNNPathfinderExtensionTool.h.

◆ m_doOutsideIn

Gaudi::Property<bool> FPGATrackSimNNPathfinderExtensionTool::m_doOutsideIn { this, "doOutsideIn", true, "Setup the tool so it's doing outside in extrap"}

private

Definition at line 174 of file FPGATrackSimNNPathfinderExtensionTool.h.

174{ this, "doOutsideIn", true, "Setup the tool so it's doing outside in extrap"};

◆ m_extensionHitNN

OnnxRuntimeBase FPGATrackSimNNPathfinderExtensionTool::m_extensionHitNN

private

Definition at line 197 of file FPGATrackSimNNPathfinderExtensionTool.h.

◆ m_extensionVolNN

OnnxRuntimeBase FPGATrackSimNNPathfinderExtensionTool::m_extensionVolNN

private

Definition at line 196 of file FPGATrackSimNNPathfinderExtensionTool.h.

◆ m_FPGATrackSimMapping

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

private

Definition at line 148 of file FPGATrackSimNNPathfinderExtensionTool.h.

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

◆ m_lowPtValueForWindowPhiScaling

Gaudi::Property<float> FPGATrackSimNNPathfinderExtensionTool::m_lowPtValueForWindowPhiScaling { this, "lowPtValueWindowPhi", -1, "Value in MeV below which we scale the phi window size"}

private

Definition at line 167 of file FPGATrackSimNNPathfinderExtensionTool.h.

167{ this, "lowPtValueWindowPhi", -1, "Value in MeV below which we scale the phi window size"};

◆ m_lowPtValueForWindowRScaling

Gaudi::Property<float> FPGATrackSimNNPathfinderExtensionTool::m_lowPtValueForWindowRScaling { this, "lowPtValueWindowR", -1, "Value in MeV below which we scale the r window size"}

private

Definition at line 163 of file FPGATrackSimNNPathfinderExtensionTool.h.

163{ this, "lowPtValueWindowR", -1, "Value in MeV below which we scale the r window size"};

◆ m_lowPtValueForWindowZScaling

Gaudi::Property<float> FPGATrackSimNNPathfinderExtensionTool::m_lowPtValueForWindowZScaling { this, "lowPtValueWindowZ", -1, "Value in MeV below which we scale the r window size"}

private

Definition at line 165 of file FPGATrackSimNNPathfinderExtensionTool.h.

165{ this, "lowPtValueWindowZ", -1, "Value in MeV below which we scale the r window size"};

◆ m_lowPtWindowPhiScaling

Gaudi::Property<float> FPGATrackSimNNPathfinderExtensionTool::m_lowPtWindowPhiScaling {this, "lowPtPhiScaling", 1.0, "Scaling factor for low pt in Phi"}

private

Definition at line 168 of file FPGATrackSimNNPathfinderExtensionTool.h.

168{this, "lowPtPhiScaling", 1.0, "Scaling factor for low pt in Phi"};

◆ m_lowPtWindowRScaling

Gaudi::Property<float> FPGATrackSimNNPathfinderExtensionTool::m_lowPtWindowRScaling {this, "lowPtRScaling", 1.0, "Scaling factor for low pt in R"}

private

Definition at line 164 of file FPGATrackSimNNPathfinderExtensionTool.h.

164{this, "lowPtRScaling", 1.0, "Scaling factor for low pt in R"};

◆ m_lowPtWindowZScaling

Gaudi::Property<float> FPGATrackSimNNPathfinderExtensionTool::m_lowPtWindowZScaling {this, "lowPtZScaling", 1.0, "Scaling factor for low pt in Z"}

private

Definition at line 166 of file FPGATrackSimNNPathfinderExtensionTool.h.

166{this, "lowPtZScaling", 1.0, "Scaling factor for low pt in Z"};

◆ m_maxBranches

Gaudi::Property<int> FPGATrackSimNNPathfinderExtensionTool::m_maxBranches { this, "maxBranches", -1, "Max number of branches before we stop, if negative this is disabled"}

private

Definition at line 173 of file FPGATrackSimNNPathfinderExtensionTool.h.

173{ this, "maxBranches", -1, "Max number of branches before we stop, if negative this is disabled"};

◆ m_maxMiss

Gaudi::Property<unsigned> FPGATrackSimNNPathfinderExtensionTool::m_maxMiss { this, "threshold", 2, "Maximum number of missing hits to reject a road"}

private

Definition at line 152 of file FPGATrackSimNNPathfinderExtensionTool.h.

152{ this, "threshold", 2, "Maximum number of missing hits to reject a road"};

◆ m_missedHitPhiScaling

Gaudi::Property<float> FPGATrackSimNNPathfinderExtensionTool::m_missedHitPhiScaling {this, "missedHitPhiScaling", -1, "Amount to scale Phi window if previous hit was missed. Negative means this is disabled"}

private

Definition at line 172 of file FPGATrackSimNNPathfinderExtensionTool.h.

172{this, "missedHitPhiScaling", -1, "Amount to scale Phi window if previous hit was missed. Negative means this is disabled"};

◆ m_missedHitRScaling

Gaudi::Property<float> FPGATrackSimNNPathfinderExtensionTool::m_missedHitRScaling {this, "missedHitRScaling", -1, "Amount to scale R window if previous hit was missed. Negative means this is disabled"}

private

Definition at line 170 of file FPGATrackSimNNPathfinderExtensionTool.h.

170{this, "missedHitRScaling", -1, "Amount to scale R window if previous hit was missed. Negative means this is disabled"};

◆ m_missedHitZScaling

Gaudi::Property<float> FPGATrackSimNNPathfinderExtensionTool::m_missedHitZScaling {this, "missedHitZScaling", -1, "Amount to scale Z window if previous hit was missed. Negative means this is disabled"}

private

Definition at line 171 of file FPGATrackSimNNPathfinderExtensionTool.h.

171{this, "missedHitZScaling", -1, "Amount to scale Z window if previous hit was missed. Negative means this is disabled"};

◆ m_nLayers_1stStage

unsigned FPGATrackSimNNPathfinderExtensionTool::m_nLayers_1stStage = 0

private

Definition at line 181 of file FPGATrackSimNNPathfinderExtensionTool.h.

◆ m_nLayers_2ndStage

unsigned FPGATrackSimNNPathfinderExtensionTool::m_nLayers_2ndStage = 0

private

Definition at line 182 of file FPGATrackSimNNPathfinderExtensionTool.h.

◆ m_predictionWindowLength

Gaudi::Property<int> FPGATrackSimNNPathfinderExtensionTool::m_predictionWindowLength { this, "predictionWindowLength", 3, "Length of hits needed for prediction"}

private

Definition at line 175 of file FPGATrackSimNNPathfinderExtensionTool.h.

175{ this, "predictionWindowLength", 3, "Length of hits needed for prediction"};

◆ m_region

Gaudi::Property<std::string> FPGATrackSimNNPathfinderExtensionTool::m_region { this, "OutputRegion", "", "region ID"}

private

Definition at line 153 of file FPGATrackSimNNPathfinderExtensionTool.h.

153{ this, "OutputRegion", "", "region ID"};

◆ m_roads

std::vector<FPGATrackSimRoad> FPGATrackSimNNPathfinderExtensionTool::m_roads

private

Definition at line 180 of file FPGATrackSimNNPathfinderExtensionTool.h.

◆ m_slicedHitHeader

FPGATrackSimLogicalEventInputHeader* FPGATrackSimNNPathfinderExtensionTool::m_slicedHitHeader = nullptr

private

Definition at line 194 of file FPGATrackSimNNPathfinderExtensionTool.h.

◆ m_tHistSvc

ServiceHandle<ITHistSvc> FPGATrackSimNNPathfinderExtensionTool::m_tHistSvc {this, "THistSvc", "THistSvc"}

private

Definition at line 149 of file FPGATrackSimNNPathfinderExtensionTool.h.

149{this, "THistSvc", "THistSvc"};

◆ m_useCartesian

Gaudi::Property<bool> FPGATrackSimNNPathfinderExtensionTool::m_useCartesian { this, "useCartesian", true, "If true, NNs use Cartestian coordinates. If false,they use cylindrical coordiantes"}

private

Definition at line 176 of file FPGATrackSimNNPathfinderExtensionTool.h.

176{ this, "useCartesian", true, "If true, NNs use Cartestian coordinates. If false,they use cylindrical coordiantes"};

◆ m_windowFineID

Gaudi::Property<std::vector<int> > FPGATrackSimNNPathfinderExtensionTool::m_windowFineID { this, "windowFineID", {0}, "Fine ID indexing for windows"}

private

Definition at line 162 of file FPGATrackSimNNPathfinderExtensionTool.h.

162{ this, "windowFineID", {0}, "Fine ID indexing for windows"};

◆ m_windowPhi

Gaudi::Property<std::vector<float> > FPGATrackSimNNPathfinderExtensionTool::m_windowPhi { this, "windowPhi", {0.4}, "Window Size to search in for phi, either pass one value for all layers or use the number of layers"}

private

Definition at line 161 of file FPGATrackSimNNPathfinderExtensionTool.h.

161{ this, "windowPhi", {0.4}, "Window Size to search in for phi, either pass one value for all layers or use the number of layers"};

◆ m_windowR

Gaudi::Property<std::vector<float> > FPGATrackSimNNPathfinderExtensionTool::m_windowR { this, "windowR", {20.0}, "Window Size to search in for r, either pass one value for all layers or use the number of layers"}

private

Definition at line 159 of file FPGATrackSimNNPathfinderExtensionTool.h.

159{ this, "windowR", {20.0}, "Window Size to search in for r, either pass one value for all layers or use the number of layers"};

◆ m_windowZ

Gaudi::Property<std::vector<float> > FPGATrackSimNNPathfinderExtensionTool::m_windowZ { this, "windowZ", {20.0}, "Window Size to search in for z, either pass one value for all layers or use the number of layers"}

private

Definition at line 160 of file FPGATrackSimNNPathfinderExtensionTool.h.

160{ this, "windowZ", {20.0}, "Window Size to search in for z, either pass one value for all layers or use the number of layers"};

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

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Function Documentation

◆ addHitToRoad()

◆ extendTracks()

◆ fillInputTensorForNN()

◆ findHitinNextStripLayer()

◆ getFakeHit()

◆ getLastLayer()

◆ getPhiScale()

◆ getPredictedHit()

◆ getPredictedHitBatched()

◆ getRScale()

◆ getXScale()

◆ getYScale()

◆ getZScale()

◆ initialize()

◆ printRoad()

◆ setupSlices()

Member Data Documentation

◆ m_batchSize

◆ m_chronoSvc

◆ m_debugEvent

◆ m_doOutsideIn

◆ m_extensionHitNN

◆ m_extensionVolNN

◆ m_FPGATrackSimMapping

◆ m_lowPtValueForWindowPhiScaling

◆ m_lowPtValueForWindowRScaling

◆ m_lowPtValueForWindowZScaling

◆ m_lowPtWindowPhiScaling

◆ m_lowPtWindowRScaling

◆ m_lowPtWindowZScaling

◆ m_maxBranches

◆ m_maxMiss

◆ m_missedHitPhiScaling

◆ m_missedHitRScaling

◆ m_missedHitZScaling

◆ m_nLayers_1stStage

◆ m_nLayers_2ndStage

◆ m_predictionWindowLength

◆ m_region

◆ m_roads

◆ m_slicedHitHeader

◆ m_tHistSvc

◆ m_useCartesian

◆ m_windowFineID

◆ m_windowPhi

◆ m_windowR

◆ m_windowZ