FPGATrackSimNNTrackTool Class Reference

#include <FPGATrackSimNNTrackTool.h>

Inheritance diagram for FPGATrackSimNNTrackTool:

Collaboration diagram for FPGATrackSimNNTrackTool:

Public Member Functions
	FPGATrackSimNNTrackTool (const std::string &, const std::string &, const IInterface *)
virtual StatusCode	initialize () override
StatusCode	getTracks_1st (std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, std::vector< FPGATrackSimTrack > &tracks)
StatusCode	getTracks_2nd (std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, std::vector< FPGATrackSimTrack > &tracks)
StatusCode	getTracks_GNN (std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, std::vector< FPGATrackSimTrack > &tracks)
StatusCode	setTrackParameters (std::vector< FPGATrackSimTrack > &tracks, bool isFirst, const FPGATrackSimTrackPars &min, const FPGATrackSimTrackPars &max)
StatusCode	setRoadSectors (std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads)
void	matchIdealGeoSector (FPGATrackSimRoad &r)
void	initialize (TString)
std::vector< float >	runONNXInference (std::vector< float > &inputTensorValues) const
std::vector< std::vector< float > >	runONNXInference (std::vector< std::vector< float > > &inputTensorValues) const
std::vector< std::vector< float > >	runONNXInference (NetworkBatchInput &inputTensorValues) const
std::map< int, Eigen::MatrixXf >	runONNXInferenceMultilayerOutput (NetworkBatchInput &inputTensorValues) const
const std::vector< int64_t > &	getInputNodesDims ()
const std::vector< int64_t > &	getOutputNodesDims ()

Static Public Member Functions
static float	getXScale ()
static float	getYScale ()
static float	getZScale ()
static float	getQoverPtScale ()
static float	getEtaScale ()
static float	getPhiScale ()
static float	getD0Scale ()
static float	getZ0Scale ()
static float	getRScale ()

Public Attributes
Gaudi::Property< unsigned int >	m_minNumberOfRealHitsInATrack { this, "MinNumberOfRealHitsInATrack", 4, "Minimum number of real hits in a track candidate to process" }
Gaudi::Property< bool >	m_doGNNTracking { this, "doGNNTracking", false, "Flag to turn on GNN Tracking configuration for road-to-track" }
Gaudi::Property< int >	m_nInputsGNN { this, "nInputsGNN", 9, "Number of Hit Inputs for NN for GNN configuration. Depends on which model is chosen."}
Gaudi::Property< bool >	m_useCartesian { this, "useCartesian", true, "If true, NNs use Cartestian coordinates. If false,they use cylindrical coordiantes"}
TString	m_fileName

Protected Attributes
ServiceHandle< IFPGATrackSimBankSvc >	m_FPGATrackSimBank { this,"FPGATrackSimBankSvc","FPGATrackSimBankSvc" }
ToolHandle< IFPGATrackSimRoadFilterTool >	m_spRoadFilterTool {this, "SPRoadFilterTool", "FPGATrackSimSpacepointRoadFilterTool", "Spacepoint Road Filter Tool"}
Gaudi::Property< bool >	m_doRegionalMapping { this, "RegionalMapping", false, "Use the sub-region maps to define the sector" }
Gaudi::Property< bool >	m_doEtaPatternConsts { this, "doEtaPatternConsts", false, "Whether to use the eta pattern tool for constant generation" }
Gaudi::Property< bool >	m_useSpacePoints { this, "useSpacePoints", false, "Whether we are using spacepoints." }
Gaudi::Property< bool >	m_useSectors { this, "useSectors", false, "Will reverse calculate the sector for track-fitting purposes" }
Gaudi::Property< bool >	m_idealGeoRoads { this, "IdealGeoRoads", true, "Set sectors to use ideal geometry fit constants" }
Gaudi::Property< bool >	m_isSecondStage { this, "isSecondStage", true, "Is this the second stage?" }
Gaudi::Property< bool >	m_do2ndStage {this, "Do2ndStageTrackFit", false, "Do 2nd stage track fit"}

Private Member Functions
void	compute_truth (FPGATrackSimTrack &newtrk) const
	OnnxRuntimeBase (TString fileName)
	OnnxRuntimeBase ()

Private Attributes
ServiceHandle< IFPGATrackSimMappingSvc >	m_FPGATrackSimMapping {this, "FPGATrackSimMappingSvc", ""}
ServiceHandle< ITHistSvc >	m_tHistSvc {this, "THistSvc","THistSvc"}
OnnxRuntimeBase	m_paramNN_1st
OnnxRuntimeBase	m_paramNN_2nd
OnnxRuntimeBase	m_fakeNN_1st
OnnxRuntimeBase	m_fakeNN_2nd
bool	m_useParamNN_1st = true
bool	m_useParamNN_2nd = true
std::vector< float >	m_x
std::vector< float >	m_y
std::vector< float >	m_z
std::vector< float >	m_barcodefrac
std::vector< int >	m_barcode
std::vector< int >	m_eventindex
std::vector< unsigned int >	m_isPixel
std::vector< unsigned int >	m_layer
std::vector< unsigned int >	m_isBarrel
std::vector< unsigned int >	m_etawidth
std::vector< unsigned int >	m_phiwidth
std::vector< unsigned int >	m_etamodule
std::vector< unsigned int >	m_phimodule
std::vector< unsigned int >	m_ID
std::vector< float >	m_truth_d0
std::vector< float >	m_truth_z0
std::vector< float >	m_truth_pt
std::vector< float >	m_truth_eta
std::vector< float >	m_truth_phi
std::vector< float >	m_truth_pdg
std::vector< int >	m_truth_q
std::vector< int >	m_truth_barcode
std::vector< int >	m_truth_eventindex
std::vector< const char * >	m_input_node_names
std::vector< int64_t >	m_input_node_dims
std::vector< const char * >	m_output_node_names
std::unique_ptr< Ort::Session >	m_session
	ONNX runtime session / model properties. More...
std::vector< const char * >	m_inputNodeNames
std::vector< int64_t >	m_inputNodeDims
std::vector< const char * >	m_outputNodeNames
std::vector< int64_t >	m_outputNodeDims
std::unique_ptr< Ort::Env >	m_env

Detailed Description

Definition at line 37 of file FPGATrackSimNNTrackTool.h.

Constructor & Destructor Documentation

FPGATrackSimNNTrackTool()

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

Definition at line 21 of file FPGATrackSimNNTrackTool.cxx.

: FPGATrackSimTrackingToolBase(algname, name, ifc), OnnxRuntimeBase() {}

Member Function Documentation

compute_truth()

void FPGATrackSimNNTrackTool::compute_truth ( FPGATrackSimTrack &  newtrk ) const

private

Definition at line 975 of file FPGATrackSimNNTrackTool.cxx.

                                                                      {
    std::vector<FPGATrackSimMultiTruth> mtv;
 
    unsigned nl = (m_do2ndStage ? 13 : 5);
    for (unsigned layer = 0; layer < nl; layer++) {
      if (!(t.getHitMap() & (1 << layer))) continue;
      
      // Sanity check that we have enough hits.
      if (layer < t.getFPGATrackSimHits().size())
    mtv.push_back(t.getFPGATrackSimHits().at(layer).getTruth());
      
      // adjust weight for hits without (and also with) a truth match, so that
      // each is counted with the same weight.
      mtv.back().assign_equal_normalization();
    }
    
    FPGATrackSimMultiTruth mt(std::accumulate(mtv.begin(), mtv.end(), FPGATrackSimMultiTruth(),
                FPGATrackSimMultiTruth::AddAccumulator()));
    // frac is then the fraction of the total number of hits on the track
    // attributed to the barcode.
 
    FPGATrackSimMultiTruth::Barcode tbarcode;
    FPGATrackSimMultiTruth::Weight tfrac;
    const bool ok = mt.best(tbarcode, tfrac);
    if (ok) {
        t.setEventIndex(tbarcode.first);
        t.setBarcode(tbarcode.second);
        t.setBarcodeFrac(tfrac);
    }
}

getD0Scale()

static float FPGATrackSimNNTrackTool::getD0Scale ( )

inlinestatic

Definition at line 60 of file FPGATrackSimNNTrackTool.h.

{ return 2.0;};

getEtaScale()

static float FPGATrackSimNNTrackTool::getEtaScale ( )

inlinestatic

Definition at line 58 of file FPGATrackSimNNTrackTool.h.

{ return 5.0;};

getInputNodesDims()

const std::vector<int64_t>& OnnxRuntimeBase::getInputNodesDims ( )

inlineinherited

Definition at line 33 of file OnnxRuntimeBase.h.

{return m_inputNodeDims;};

getOutputNodesDims()

const std::vector<int64_t>& OnnxRuntimeBase::getOutputNodesDims ( )

inlineinherited

Definition at line 34 of file OnnxRuntimeBase.h.

{return m_outputNodeDims;};

getPhiScale()

static float FPGATrackSimNNTrackTool::getPhiScale ( )

inlinestatic

Definition at line 59 of file FPGATrackSimNNTrackTool.h.

{ return 3.15;};

getQoverPtScale()

static float FPGATrackSimNNTrackTool::getQoverPtScale ( )

inlinestatic

Definition at line 57 of file FPGATrackSimNNTrackTool.h.

{ return 0.001;};

getRScale()

static float FPGATrackSimNNTrackTool::getRScale ( )

inlinestatic

Definition at line 62 of file FPGATrackSimNNTrackTool.h.

{return 1015.;};

getTracks_1st()

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

should be 2 missing coords for pixel

now we have saved our values, time to run inference and get the output

Definition at line 233 of file FPGATrackSimNNTrackTool.cxx.

                                                                                                                                               {
 
    if(m_doGNNTracking) {
        ATH_CHECK(getTracks_GNN(roads, tracks));
        return StatusCode::SUCCESS;
    }
 
    ATH_CHECK(setRoadSectors(roads));
    int n_track = 0;
 
    std::vector<std::vector<float> >inputTensorValuesAll;
 
    // Loop over roads
    for (auto const &iroad : roads) {
 
        double y = iroad->getY();
 
        // Just used to get number of layers considered
        const FPGATrackSimPlaneMap *planeMap = m_FPGATrackSimMapping->PlaneMap_1st(iroad->getSubRegion());
 
        // Get info on layers with missing hits
        int nMissing = 0;
        layer_bitmask_t missing_mask = iroad->getNWCLayers();
    for (unsigned ilayer = 0; ilayer < planeMap->getNLogiLayers(); ilayer++) {
      if ((missing_mask >> ilayer) & 0x1) {
        nMissing++;
        if (planeMap->isPixel(ilayer)) nMissing++; 
      }
    }
    
 
        // Create a template track with common parameters filled already for
        // initializing below
        FPGATrackSimTrack temp;
        temp.setTrackStage(TrackStage::FIRST);
        temp.setNLayers(planeMap->getNLogiLayers());
        temp.setBankID(-1);
        temp.setPatternID(iroad->getPID());
        temp.setFirstSectorID(iroad->getSector());
        temp.setHitMap(missing_mask);
        temp.setNMissing(nMissing);
        temp.setQOverPt(y);
 
        temp.setSubRegion(iroad->getSubRegion());
        temp.setHoughX(iroad->getX());
        temp.setHoughY(iroad->getY());
        temp.setHoughXBin(iroad->getXBin());
        temp.setHoughYBin(iroad->getYBin());
 
        temp.setBinIdx(iroad->getBinIdx());
 
        // Get a list of indices for all possible combinations given a certain
        // number of layers
        std::vector<std::vector<int>> combs;
        
        combs = getComboIndices(iroad->getNHits_layer());
 
        // Loop over possible combinations for this road
        for (size_t icomb = 0; icomb < combs.size(); icomb++) {
            std::vector<float> inputTensorValues;
            std::vector<std::shared_ptr<const FPGATrackSimHit>> hit_list;
 
            // list of indices for this particular combination
            std::vector<int> const &hit_indices = combs[icomb];
 
            // Loop over all layers
            for (unsigned layer = 0; layer < planeMap->getNLogiLayers(); layer++) {
 
                // Check to see if this is a valid hit
                if (hit_indices[layer] >= 0) {
 
                    std::shared_ptr<const FPGATrackSimHit> hit = iroad->getHits(layer)[hit_indices[layer]];
                    // Add this hit to the road
                    if (hit->isReal()){
                        hit_list.push_back(std::move(hit));
                    }
                }
            }
 
            // Sort the list by radial distance
            std::sort(hit_list.begin(), hit_list.end(),
                    [](std::shared_ptr<const FPGATrackSimHit> &hit1, std::shared_ptr<const FPGATrackSimHit> &hit2) {
                    double rho1 = std::hypot(hit1->getX(), hit1->getY());
                    double rho2 = std::hypot(hit2->getX(), hit2->getY());
                    return rho1 < rho2;
                    });
 
 
            int index = 1;
            bool flipZ = false;
            double rotateAngle = 0;
            bool gotSecondSP = false;
            float tmp_xf;
            float tmp_yf;
            float tmp_zf;
        float tmp_rf;
        float tmp_phif;
            // Loop over all hits
            for (const auto &hit : hit_list) {
                // Need to rotate hits
                float x0 = hit->getX();
                float y0 = hit->getY();
                float z0 = hit->getZ();
        float r0 = std::sqrt(x0*x0+y0*y0);
        float phi0 = hit->getGPhi();
        float xf = x0;
        float yf = y0;
        float zf = z0;
        float rf = r0;
        float phif = phi0;
        if (m_useCartesian) {
          if (index == 1) {
            if (z0 < 0)
              flipZ = true;
            rotateAngle = std::atan(x0 / y0);
            if (y0 < 0)
              rotateAngle += M_PI;
          }       
          xf = x0 * std::cos(rotateAngle) - y0 * std::sin(rotateAngle);
          yf = x0 * std::sin(rotateAngle) + y0 * std::cos(rotateAngle);
          zf = z0;
          if (flipZ) zf = z0 * -1;
        }
 
                // Get average of values for strip hit pairs
                // TODO: this needs to be fixed in the future, for this to work for other cases
                if (hit->isStrip()) {
          
          if (hit->getHitType() != HitType::spacepoint) { // this is a strip but not a SP!
            if (m_useCartesian) {
              float xf_scaled = (xf) / (getXScale());
              float yf_scaled = (yf) / (getYScale());
              float zf_scaled = (zf) / (getZScale());
              
              // Get average of two hits for strip hits
              inputTensorValues.push_back(xf_scaled);
              inputTensorValues.push_back(yf_scaled);
              inputTensorValues.push_back(zf_scaled);
              
            }
            else {
              float rf_scaled = (rf) / (getRScale());
              float phif_scaled = (phif) / (getPhiScale());
              float zf_scaled = (zf) / (getZScale());
              // Get average of two hits for strip hits
              inputTensorValues.push_back(rf_scaled);
              inputTensorValues.push_back(phif_scaled);
              inputTensorValues.push_back(zf_scaled);
            }
          }         
          else if (!gotSecondSP) {
            tmp_xf = xf;
            tmp_yf = yf;
            tmp_zf = zf;
            tmp_phif = phif;
            tmp_rf = rf;
            gotSecondSP = true;
          }
          else {
            gotSecondSP = false;
            if (m_useCartesian) {
              float xf_scaled = (xf + tmp_xf) / (2.*getXScale());
              float yf_scaled = (yf + tmp_yf) / (2.*getYScale());
              float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
              
              // Get average of two hits for strip hits 
              inputTensorValues.push_back(xf_scaled);
              inputTensorValues.push_back(yf_scaled);
              inputTensorValues.push_back(zf_scaled);
              index++;
            }
            else {
              float rf_scaled = (rf + tmp_rf) / (2.*getRScale());
              float phif_scaled = (phif + tmp_phif) / (2.*getPhiScale());
              float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
              inputTensorValues.push_back(rf_scaled);
              inputTensorValues.push_back(phif_scaled);
              inputTensorValues.push_back(zf_scaled);
            }
          }
                }
                else {
          if (m_useCartesian) {
            float xf_scaled = (xf) / (getXScale());
                    float yf_scaled = (yf) / (getYScale());
                    float zf_scaled = (zf) / (getZScale());
                    inputTensorValues.push_back(xf_scaled);
                    inputTensorValues.push_back(yf_scaled);
                    inputTensorValues.push_back(zf_scaled);
                    index++;
          }
          else {
            float rf_scaled = (rf) / (getRScale());
            float phif_scaled = (phif) / (getPhiScale());
            float zf_scaled = (zf) / (getZScale());
            inputTensorValues.push_back(rf_scaled);
            inputTensorValues.push_back(phif_scaled);
            inputTensorValues.push_back(zf_scaled);
          }
                }
            }
        
            if (inputTensorValues.size() != planeMap->getNLogiLayers()*3) {
                inputTensorValues.resize(planeMap->getNLogiLayers()*3);
            }
            inputTensorValues.resize(15); // Retain only the first 15 values for consistency
        
            inputTensorValuesAll.push_back(inputTensorValues);
            FPGATrackSimTrack track_cand;
        n_track++;
            track_cand.setTrackID(n_track);
            track_cand.setNLayers(planeMap->getNLogiLayers());
        track_cand.setNMissing(nMissing);
            for (unsigned ihit = 0; ihit < hit_list.size(); ihit++) {
                track_cand.setFPGATrackSimHit(ihit, *(hit_list[ihit]));
            }
            tracks.push_back(track_cand);
 
            ATH_MSG_DEBUG("NN InputTensorValues:");
            ATH_MSG_DEBUG(inputTensorValues);
        }  // loop over combinations
    }  // loop over roads
 
    auto NNoutputs = m_fakeNN_1st.runONNXInference(inputTensorValuesAll);
 
    for (unsigned itrack = 0; itrack < NNoutputs.size(); itrack++) {
 
        float nn_val = NNoutputs[itrack][0];
        ATH_MSG_DEBUG("NN output:" << nn_val);
        double chi2 = (1 - nn_val) * (tracks[itrack].getNCoords() - tracks[itrack].getNMissing() - 5);
    //std::cout << "1st stage" <<  chi2 << std::endl;
    tracks[itrack].setOrigChi2(chi2);
        tracks[itrack].setChi2(chi2);
    }
 
    // Add truth info
    for (FPGATrackSimTrack &t : tracks) {
        compute_truth(t);  // match the track to a geant particle using the
        // channel-level geant info in the hit data.
    }
    return StatusCode::SUCCESS;
}

getTracks_2nd()

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

should be 2 missing coords for pixel

now we have saved our values, time to run inference and get the output

Definition at line 479 of file FPGATrackSimNNTrackTool.cxx.

                                                                                                                                               {
 
    ATH_CHECK(setRoadSectors(roads));
    int n_track = 0;
    std::vector<std::vector<float> >inputTensorValuesAll;
 
    // Loop over roads
    for (auto const &iroad : roads) {
 
        double y = iroad->getY();
 
    const FPGATrackSimPlaneMap *planeMap = m_FPGATrackSimMapping->PlaneMap_2nd(iroad->getSubRegion());
        // Get info on layers with missing hits
        int nMissing = 0;
        layer_bitmask_t missing_mask = iroad->getNWCLayers();
    layer_bitmask_t hit_mask = 0x0;
    for (unsigned ilayer = 0; ilayer < 13; ilayer++) {
      if ((missing_mask >> ilayer) & 0x1) {
        nMissing++;
        if (planeMap->isPixel(ilayer)) nMissing++; 
      }
      else {
        hit_mask |= (0x1 << ilayer);
      }
    }
        
        // Create a template track with common parameters filled already for
        // initializing below
        FPGATrackSimTrack temp;
        temp.setTrackStage(TrackStage::SECOND);
        temp.setNLayers(13);
        temp.setBankID(-1);
        temp.setPatternID(iroad->getPID());
        temp.setFirstSectorID(iroad->getSector());
        temp.setHitMap(hit_mask);
        temp.setNMissing(nMissing);
        temp.setQOverPt(y);
 
        temp.setSubRegion(iroad->getSubRegion());
        temp.setHoughX(iroad->getX());
        temp.setHoughY(iroad->getY());
        temp.setHoughXBin(iroad->getXBin());
        temp.setHoughYBin(iroad->getYBin());
        // Get a list of indices for all possible combinations given a certain
        // number of layers
        std::vector<std::vector<int>> combs =
            getComboIndices(iroad->getNHits_layer());
 
        // Loop over possible combinations for this road
        for (size_t icomb = 0; icomb < combs.size(); icomb++) {
            std::vector<float> inputTensorValues;
 
            // list of indices for this particular combination
            std::vector<int> const &hit_indices = combs[icomb];
            std::vector<std::shared_ptr<const FPGATrackSimHit>> hit_list;
 
            // Loop over all layers
            for (unsigned layer = 0; layer < 13; layer++) {
 
                // Check to see if this is a valid hit
                if (hit_indices[layer] >= 0) {
 
                    std::shared_ptr<const FPGATrackSimHit> hit = iroad->getHits(layer)[hit_indices[layer]];
                    // Add this hit to the road
                    if (hit->isReal()){
                        hit_list.push_back(hit);
                    }
                }
            }
 
            // Sort the list by radial distance
            std::sort(hit_list.begin(), hit_list.end(),
                    [](std::shared_ptr<const FPGATrackSimHit> &hit1, std::shared_ptr<const FPGATrackSimHit> &hit2) {
                    double rho1 = std::hypot(hit1->getX(), hit1->getY());
                    double rho2 = std::hypot(hit2->getX(), hit2->getY());
                    return rho1 < rho2;
                    });
 
 
            int index = 1;
            bool flipZ = false;
            double rotateAngle = 0;
            bool gotSecondSP = false;
            float tmp_xf;
            float tmp_yf;
            float tmp_zf;
        float tmp_rf;
        float tmp_phif;
            // Loop over all hits
            for (const auto &hit : hit_list) {
 
                // Need to rotate hits
                float x0 = hit->getX();
                float y0 = hit->getY();
                float z0 = hit->getZ();
        float r0 = std::sqrt(x0*x0+y0*y0);
                float phi0 = hit->getGPhi();
                float xf = x0;
                float yf = y0;
                float zf = z0;
        float rf = r0;
        float phif = phi0;
        
        if (m_useCartesian) {
          if (index == 1) {
                    if (z0 < 0)
              flipZ = true;
                    rotateAngle = std::atan(x0 / y0);
                    if (y0 < 0)
              rotateAngle += M_PI;
          }       
          xf = x0 * std::cos(rotateAngle) - y0 * std::sin(rotateAngle);
          yf = x0 * std::sin(rotateAngle) + y0 * std::cos(rotateAngle);
          zf = z0;
          
          if (flipZ) zf = z0 * -1;
        }
 
                // Get average of values for strip hit pairs
                // TODO: this needs to be fixed in the future, for this to work for other cases
                if (hit->isStrip()) {
 
          if (hit->getHitType() != HitType::spacepoint) { // this is a strip but not a SP!
            if (m_useCartesian) {
              float xf_scaled = (xf) / (getXScale());
              float yf_scaled = (yf) / (getYScale());
              float zf_scaled = (zf) / (getZScale());
              
              // Get average of two hits for strip hits
              inputTensorValues.push_back(xf_scaled);
              inputTensorValues.push_back(yf_scaled);
              inputTensorValues.push_back(zf_scaled);             
            }
            else {
              float rf_scaled = (rf) / (getRScale());
              float phif_scaled = (phif) / (getPhiScale());
              float zf_scaled = (zf) / (getZScale());
              // Get average of two hits for strip hits
              inputTensorValues.push_back(rf_scaled);
              inputTensorValues.push_back(phif_scaled);
              inputTensorValues.push_back(zf_scaled);
            }
          }
          else if (!gotSecondSP) {
            tmp_xf = xf;
            tmp_yf = yf;
            tmp_zf = zf;
            tmp_rf = rf;
            tmp_phif = phif;
            gotSecondSP = true;
          }
          else {
            gotSecondSP = false;
            if (m_useCartesian) {
              float xf_scaled = (xf + tmp_xf) / (2.*getXScale());
              float yf_scaled = (yf + tmp_yf) / (2.*getYScale());
              float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
              
              // Get average of two hits for strip hits
              inputTensorValues.push_back(xf_scaled);
              inputTensorValues.push_back(yf_scaled);
              inputTensorValues.push_back(zf_scaled);
              index++;
            }
            else {
              float rf_scaled = (rf + tmp_rf) / (2.*getRScale());
              float phif_scaled = (phif + tmp_phif) / (2.*getPhiScale());
              float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
              inputTensorValues.push_back(rf_scaled);
              inputTensorValues.push_back(phif_scaled);
              inputTensorValues.push_back(zf_scaled);
            }
          }
        }
        else {
          if (m_useCartesian) {
                    float xf_scaled = (xf) / (getXScale());
                    float yf_scaled = (yf) / (getYScale());
                    float zf_scaled = (zf) / (getZScale());
                    inputTensorValues.push_back(xf_scaled);
                    inputTensorValues.push_back(yf_scaled);
                    inputTensorValues.push_back(zf_scaled);
                    index++;
          }
          else {
                    float rf_scaled = (rf) / (getRScale());
                    float phif_scaled = (phif) / (getPhiScale());
                    float zf_scaled = (zf) / (getZScale());
                    inputTensorValues.push_back(rf_scaled);
                    inputTensorValues.push_back(phif_scaled);
                    inputTensorValues.push_back(zf_scaled);
          }
        }
        }
        
        
        if (inputTensorValues.size() < 39) {
          inputTensorValues.resize(39, 0.0f); // Resize to 39 and fill with 0.0f
        }
        else if (inputTensorValues.size() > 39) {
          inputTensorValues.resize(39); // Resize to 39 and keep the first 39 elements
        }
            inputTensorValuesAll.push_back(inputTensorValues);
 
            ATH_MSG_DEBUG("NN InputTensorValues:");
            ATH_MSG_DEBUG(inputTensorValues);
 
            n_track++;
            FPGATrackSimTrack track_cand;
            track_cand.setTrackID(n_track);
            track_cand.setNLayers(13);
        track_cand.setNMissing(nMissing);
            for (unsigned ihit = 0; ihit < hit_list.size(); ihit++) {
                track_cand.setFPGATrackSimHit(ihit, *(hit_list[ihit]));
            }
            tracks.push_back(track_cand);
 
        }  // loop over combinations
    }  // loop over roads
 
    auto NNoutputs = m_fakeNN_2nd.runONNXInference(inputTensorValuesAll);
    for (unsigned itrack = 0; itrack < NNoutputs.size(); itrack++) {
 
        float nn_val = NNoutputs[itrack][0];
        ATH_MSG_DEBUG("NN output:" << nn_val);
 
        double chi2 = (1 - nn_val) * (tracks[itrack].getNCoords() - tracks[itrack].getNMissing() - 5);
    
        tracks[itrack].setOrigChi2(chi2);
        tracks[itrack].setChi2(chi2);
    }
 
    // Add truth info
    for (FPGATrackSimTrack &t : tracks) {
        compute_truth(t);  // match the track to a geant particle using the
        // channel-level geant info in the hit data.
    }
 
    return StatusCode::SUCCESS;
}

getTracks_GNN()

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

should be 2 missing coords for pixel

now we have saved our values, time to run inference and get the output

Definition at line 722 of file FPGATrackSimNNTrackTool.cxx.

                                                                                                                                               {
 
    ATH_CHECK(setRoadSectors(roads));
    int n_track = 0;
 
    std::vector<std::vector<float> >inputTensorValuesAll;
 
    // Loop over roads
    for (auto const &iroad : roads) {
        // Just used to get number of layers considered
        const FPGATrackSimPlaneMap *planeMap = m_FPGATrackSimMapping->PlaneMap_1st(iroad->getSubRegion());
 
        double y = iroad->getY();
 
        // Get info on layers with missing hits
        int nMissing = 0;
        layer_bitmask_t missing_mask = 0;
    layer_bitmask_t hit_mask = 0x0;
    for (unsigned ilayer = 0; ilayer < 13; ilayer++) {
      if ((missing_mask >> ilayer) & 0x1) {
        nMissing++;
        if (planeMap->isPixel(ilayer)) nMissing++; 
      }
      else {
        hit_mask |= (0x1 << ilayer);
      }
    }
 
 
        // Create a template track with common parameters filled already for
        // initializing below
        FPGATrackSimTrack temp;
        temp.setTrackStage(TrackStage::FIRST);
        temp.setNLayers(planeMap->getNLogiLayers());
        temp.setBankID(-1);
        temp.setPatternID(iroad->getPID());
        temp.setFirstSectorID(iroad->getSector());
        temp.setHitMap(hit_mask);
        temp.setNMissing(nMissing);
        temp.setQOverPt(y);
 
        temp.setSubRegion(iroad->getSubRegion());
        temp.setHoughX(iroad->getX());
        temp.setHoughY(iroad->getY());
        temp.setHoughXBin(iroad->getXBin());
        temp.setHoughYBin(iroad->getYBin());
 
        // Get a list of indices for all possible combinations given a certain
        // number of layers
        std::vector<std::vector<int>> combs;
        std::vector<std::shared_ptr<const FPGATrackSimHit>> all_hits;
 
        std::vector<std::shared_ptr<const FPGATrackSimHit>> all_pixel_hits;
        std::vector<std::shared_ptr<const FPGATrackSimHit>> all_strip_hits;
        size_t pixelCount = 0;
 
        for (unsigned layer = 0; layer < iroad->getNLayers(); ++layer) {
            all_hits.insert(all_hits.end(), iroad->getHits(layer).begin(), iroad->getHits(layer).end());
        }
 
        for (const auto& hit : all_hits) {
            if(hit->isPixel()) {
                pixelCount++;
            }
        }
 
        if (pixelCount < 1) continue; // Cannot use a form a track candidate from a road that does not have a pixel hit
 
        std::vector<float> inputTensorValues;
        std::vector<std::shared_ptr<const FPGATrackSimHit>> hit_list;
 
        for (const auto &hit : all_hits) {
            if (hit->isReal()) {
                hit_list.push_back(hit);
            }
        }
 
        if (hit_list.size() < m_minNumberOfRealHitsInATrack) continue;
 
        // Sort the list by radial distance
        std::sort(hit_list.begin(), hit_list.end(),
                [](std::shared_ptr<const FPGATrackSimHit> &hit1, std::shared_ptr<const FPGATrackSimHit> &hit2) {
                double rho1 = std::hypot(hit1->getX(), hit1->getY());
                double rho2 = std::hypot(hit2->getX(), hit2->getY());
                return rho1 < rho2;
                });
 
 
        int index = 1;
        bool flipZ = false;
        double rotateAngle = 0;
        bool gotSecondSP = false;
        float tmp_xf;
        float tmp_yf;
        float tmp_zf;
        float tmp_phif;
        float tmp_rf;       
 
        // Loop over all hits
        for (const auto &hit : hit_list) {
            // Need to rotate hits
            float x0 = hit->getX();
            float y0 = hit->getY();
            float z0 = hit->getZ();
        float r0 = std::sqrt(x0*x0+y0*y0);
        float phi0 = hit->getGPhi();
        float xf = x0;
        float yf = y0;
        float zf = z0;
        float rf = r0;
        float phif = phi0;
        
        if (m_useCartesian) {
          if (index == 1) {
                if (z0 < 0)
          flipZ = true;
                rotateAngle = std::atan(x0 / y0);
                if (y0 < 0)
          rotateAngle += M_PI;
          }       
          xf = x0 * std::cos(rotateAngle) - y0 * std::sin(rotateAngle);
          yf = x0 * std::sin(rotateAngle) + y0 * std::cos(rotateAngle);
          zf = z0;
          
          if (flipZ) zf = z0 * -1;
        }
        
            // Get average of values for strip hit pairs
            // TODO: this needs to be fixed in the future, for this to work for other cases
            if (hit->isStrip()) {
 
          if (hit->getHitType() != HitType::spacepoint) { // this is a strip but not a SP!
        if (m_useCartesian) {
          float xf_scaled = (xf) / (getXScale());
          float yf_scaled = (yf) / (getYScale());
          float zf_scaled = (zf) / (getZScale());
          
          // Get average of two hits for strip hits
          inputTensorValues.push_back(xf_scaled);
          inputTensorValues.push_back(yf_scaled);
          inputTensorValues.push_back(zf_scaled);
          
        }
        else {
          float rf_scaled = (rf) / (getRScale());
          float phif_scaled = (phif) / (getPhiScale());
          float zf_scaled = (zf) / (getZScale());
          // Get average of two hits for strip hits
          inputTensorValues.push_back(rf_scaled);
          inputTensorValues.push_back(phif_scaled);
          inputTensorValues.push_back(zf_scaled);
        }
          }
          else if (!gotSecondSP) {
        tmp_xf = xf;
        tmp_yf = yf;
        tmp_zf = zf;
        tmp_phif = phif;
        tmp_rf = rf;
        gotSecondSP = true;
          }
          else {
        gotSecondSP = false;
        if (m_useCartesian) {
          float xf_scaled = (xf + tmp_xf) / (2.*getXScale());
          float yf_scaled = (yf + tmp_yf) / (2.*getYScale());
          float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
          
          // Get average of two hits for strip hits 
          inputTensorValues.push_back(xf_scaled);
          inputTensorValues.push_back(yf_scaled);
          inputTensorValues.push_back(zf_scaled);
          index++;
        }
        else {
          float rf_scaled = (rf + tmp_rf) / (2.*getRScale());
          float phif_scaled = (phif + tmp_phif) / (2.*getPhiScale());
          float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
          inputTensorValues.push_back(rf_scaled);
          inputTensorValues.push_back(phif_scaled);
          inputTensorValues.push_back(zf_scaled);
        }
          }
            }
            else {
          if (m_useCartesian) {
                float xf_scaled = (xf) / (getXScale());
                float yf_scaled = (yf) / (getYScale());
                float zf_scaled = (zf) / (getZScale());
                inputTensorValues.push_back(xf_scaled);
                inputTensorValues.push_back(yf_scaled);
                inputTensorValues.push_back(zf_scaled);
                index++;
          }
          else {
        float rf_scaled = (rf) / (getRScale());
        float phif_scaled = (phif) / (getPhiScale());
        float zf_scaled = (zf) / (getZScale());
        inputTensorValues.push_back(rf_scaled);
        inputTensorValues.push_back(phif_scaled);
        inputTensorValues.push_back(zf_scaled);
          }
            }
        }
 
        // NN Estimator can either be 5 or 9 spacepoints as inputs
        // Let this be decided by m_nInputsGNN
 
        // NN Estimator needs 9 spacepoints -> 27 inputs
        // If there are more than 9 spacepoints entered, then it accepts the first 9
        // If there are less than 9 spacepoints, then it enters no values for it (although I actually probably need to just reject these)
        inputTensorValues.resize(m_nInputsGNN * 3); 
        
        inputTensorValuesAll.push_back(inputTensorValues);
        FPGATrackSimTrack track_cand;
        track_cand.setTrackID(n_track);
        track_cand.setNLayers(hit_list.size());
        for (unsigned ihit = 0; ihit < hit_list.size(); ihit++) {
            track_cand.setFPGATrackSimHit(ihit, *(hit_list[ihit]));
        }
        tracks.push_back(track_cand);
 
 
        ATH_MSG_DEBUG("NN InputTensorValues:");
        ATH_MSG_DEBUG(inputTensorValues);
    }  // loop over roads
 
    auto NNoutputs = m_fakeNN_1st.runONNXInference(inputTensorValuesAll);
 
    for (unsigned itrack = 0; itrack < NNoutputs.size(); itrack++) {
 
        float nn_val = NNoutputs[itrack][0];
        ATH_MSG_DEBUG("NN output:" << nn_val);
        double chi2 = (1 - nn_val) * (tracks[itrack].getNCoords() - tracks[itrack].getNMissing() - 5);
        tracks[itrack].setOrigChi2(chi2);
        tracks[itrack].setChi2(chi2);
    }
 
    // Add truth info
    for (FPGATrackSimTrack &t : tracks) {
        compute_truth(t);  // match the track to a geant particle using the
        // channel-level geant info in the hit data.
    }
 
    return StatusCode::SUCCESS;
}

getXScale()

static float FPGATrackSimNNTrackTool::getXScale ( )

inlinestatic

Definition at line 54 of file FPGATrackSimNNTrackTool.h.

{ return 1015.;};

getYScale()

static float FPGATrackSimNNTrackTool::getYScale ( )

inlinestatic

Definition at line 55 of file FPGATrackSimNNTrackTool.h.

{ return 1015.;};

getZ0Scale()

static float FPGATrackSimNNTrackTool::getZ0Scale ( )

inlinestatic

Definition at line 61 of file FPGATrackSimNNTrackTool.h.

{ return 200.;};        

getZScale()

static float FPGATrackSimNNTrackTool::getZScale ( )

inlinestatic

Definition at line 56 of file FPGATrackSimNNTrackTool.h.

{ return 3000.;};

initialize() [1/2]

StatusCode FPGATrackSimNNTrackTool::initialize ( )

overridevirtual

Definition at line 25 of file FPGATrackSimNNTrackTool.cxx.

                                               {
    ATH_CHECK(m_FPGATrackSimMapping.retrieve());
    ATH_CHECK(m_tHistSvc.retrieve());
    if (m_useSpacePoints) ATH_CHECK(m_spRoadFilterTool.retrieve(EnableTool{m_spRoadFilterTool}));
 
    if (m_FPGATrackSimMapping->getFakeNNMapString() != "") {
        m_fakeNN_1st.initialize(m_FPGATrackSimMapping->getFakeNNMapString());
    }
    else {
        ATH_MSG_ERROR("Path to 1st stage NN-based fake track removal ONNX file is empty! If you want to run this pipeline, you need to provide an input file.");
        return StatusCode::FAILURE;
    }
 
    if (m_FPGATrackSimMapping->getParamNNMapString() != "") {
        m_paramNN_1st.initialize(m_FPGATrackSimMapping->getParamNNMapString());
    }
    else {
        ATH_MSG_INFO("Path 1st stage to NN-based track parameter estimation ONNX file is empty! Estimation is not run...");
        m_useParamNN_1st = false;
    }
 
    if (m_FPGATrackSimMapping->getFakeNNMap2ndString() != "") {
        m_fakeNN_2nd.initialize(m_FPGATrackSimMapping->getFakeNNMap2ndString());
    }
    else {
        ATH_MSG_ERROR("Path to 2nd stage NN-based fake track 1st stage removal ONNX file is empty! If you want to run this pipeline, you need to provide an input file.");
        return StatusCode::FAILURE;
    }
 
    if (m_FPGATrackSimMapping->getParamNNMap2ndString() != "") {
        m_paramNN_2nd.initialize(m_FPGATrackSimMapping->getParamNNMap2ndString());
    }
    else {
        ATH_MSG_INFO("Path to 2nd stage NN-based track parameter estimation 2nd ONNX file is empty! Estimation is not run...");
        m_useParamNN_2nd = false;
    }
 
    return StatusCode::SUCCESS;
}

initialize() [2/2]

void OnnxRuntimeBase::initialize ( TString  fileName )

inherited

Definition at line 16 of file OnnxRuntimeBase.cxx.

{
  m_fileName = std::move(fileName);
  //load the onnx model to memory using the path m_path_to_onnx
  m_env = std::make_unique< Ort::Env >(ORT_LOGGING_LEVEL_WARNING, "");
 
  // Set the ONNX runtime session options
  Ort::SessionOptions session_options;
  // Set graph optimization level
  session_options.SetIntraOpNumThreads(1);
  session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED);
  // Create the Ort session
  m_session = std::make_unique< Ort::Session >(*m_env, m_fileName.Data(), session_options);
  // Default allocator
  Ort::AllocatorWithDefaultOptions allocator;
  // Get the names of the input nodes of the model
  size_t numInputNodes = m_session->GetInputCount();
  // Iterate over all input nodes and get the name
  for (size_t i = 0; i < numInputNodes; i++) 
  {
    auto name = m_session->GetInputNameAllocated(i, allocator);
    char* input_name = new char[strlen(name.get()) + 1];
    strcpy(input_name, name.get());
 
    m_inputNodeNames.push_back(input_name);
    // Get the dimensions of the input nodes,
    // here we assume that all input nodes have the same dimensions
    Ort::TypeInfo inputTypeInfo = m_session->GetInputTypeInfo(i);
    auto tensorInfo = inputTypeInfo.GetTensorTypeAndShapeInfo();
 
    m_inputNodeDims = tensorInfo.GetShape();
  }
  // Get the names of the output nodes
  size_t numOutputNodes = m_session->GetOutputCount();
  // Iterate over all output nodes and get the name
  for (size_t i = 0; i < numOutputNodes; i++) 
  {
    auto name = m_session->GetOutputNameAllocated(i, allocator);
    char* output_name = new char[strlen(name.get()) + 1];
    strcpy(output_name, name.get());
    m_outputNodeNames.push_back(output_name);
    // Get the dimensions of the output nodes
    // here we assume that all output nodes have the dimensions
    Ort::TypeInfo outputTypeInfo = m_session->GetOutputTypeInfo(i);
    auto tensorInfo = outputTypeInfo.GetTensorTypeAndShapeInfo();
    m_outputNodeDims = tensorInfo.GetShape();
  }
}

matchIdealGeoSector()

void FPGATrackSimTrackingToolBase::matchIdealGeoSector ( FPGATrackSimRoad &  r )

inherited

Definition at line 36 of file FPGATrackSimTrackingToolBase.cxx.

{
    // We now look up the binning information in the sector bank.
    const FPGATrackSimSectorBank* sectorbank = nullptr;
    if(! m_do2ndStage)
      sectorbank = m_FPGATrackSimBank->SectorBank_1st();
    else
      sectorbank = m_FPGATrackSimBank->SectorBank_2nd();
 
    // Look up q/pt (or |q/pt|) from the Hough road, convert to MeV.
    double qoverpt = r.getY()*0.001;
    if (sectorbank->isAbsQOverPtBinning()) {
       qoverpt = std::abs(qoverpt);
    }
 
    // Retrieve the bin boundaries from the sector bank; map this onto them.
    const std::vector<double> &qoverpt_bins = sectorbank->getQOverPtBins();
    auto bounds = std::equal_range(qoverpt_bins.begin(), qoverpt_bins.end(), qoverpt);
 
    // estimate sectorbin
    int sectorbin = fpgatracksim::QPT_SECTOR_OFFSET * (bounds.first - qoverpt_bins.begin() - 1);
    sectorbin = std::clamp(sectorbin, 0, 10 * static_cast<int>(qoverpt_bins.size() - 2));
    if (m_do2ndStage) sectorbin = 0;
 
    if (m_doRegionalMapping){
      int subregion = r.getSubRegion();
      sectorbin += subregion*fpgatracksim::SUBREGION_SECTOR_OFFSET;
    }
 
    std::vector<module_t> modules(r.getNLayers(), -1);
    layer_bitmask_t wc_layers = r.getWCLayers();
    for (unsigned int il = 0; il < r.getNLayers(); il++) {
        if (r.getNHits_layer()[il] == 0) {
 
            // set corresponding bit to 1 in case of wc in the current layer
            wc_layers |= (0x1 << il);
 
            std::unique_ptr<FPGATrackSimHit> wcHit = std::make_unique<FPGATrackSimHit>();
            wcHit->setHitType(HitType::wildcard);
            wcHit->setLayer(il);
            if(! m_do2ndStage)
              wcHit->setDetType(m_FPGATrackSimMapping->PlaneMap_1st(0)->getDetType(il));
            else
              wcHit->setDetType(m_FPGATrackSimMapping->PlaneMap_2nd(0)->getDetType(il));
 
            // Now store wc hit in a "std::vector<std::shared_ptr<const FPGATrackSimHit>>" format.
            // We can probably avoid initializing an intermediate variable wcHits as we used to do
            r.setHits(il,{std::move(wcHit)});
        }
        else {
            modules[il]= sectorbin;
        }
    }
    r.setWCLayers(wc_layers);
 
 
    // If we are using eta patterns. We need to first run the roads through the road filter.
    // Then the filter will be responsible for setting the actual sector.
    // As a hack, we can store the sector bin ID in the road for now.
    // This is fragile! If we want to store a different ID for each layer, it will break.
 
    // Similarly, we do the same thing for spacepoints. this probably means we can't combine the two.
    // maybe better to store the module array instead of just a number?
    
    r.setSectorBin(sectorbin);
    if (!m_doEtaPatternConsts && !m_useSpacePoints) {
        r.setSector(sectorbank->findSector(modules));
    }
}

OnnxRuntimeBase() [1/2]

OnnxRuntimeBase::OnnxRuntimeBase

private

Definition at line 24 of file OnnxRuntimeBase.cxx.

{}

OnnxRuntimeBase() [2/2]

OnnxRuntimeBase::OnnxRuntimeBase

private

Definition at line 23 of file OnnxRuntimeBase.cxx.

{
    initialize(std::move(fileName));
}

runONNXInference() [1/3]

std::vector< std::vector< float > > OnnxRuntimeBase::runONNXInference ( NetworkBatchInput &  inputTensorValues ) const

inherited

Definition at line 96 of file OnnxRuntimeBase.cxx.

{
  int batchSize = inputTensorValues.rows();
  std::vector<int64_t> inputNodeDims = m_inputNodeDims;
  std::vector<int64_t> outputNodeDims = m_outputNodeDims; //bad. Assumes they all have the same number of nodes.
 
  // The first dim node should correspond to the batch size
  // If it is -1, it is dynamic and should be set to the input size
  if (inputNodeDims[0] == -1) 
  {
    inputNodeDims[0] = batchSize;
  }
  if (outputNodeDims[0] == -1) 
  {
    outputNodeDims[0] = batchSize;
  }
 
  if(inputNodeDims[1]*inputNodeDims[2] != inputTensorValues.cols() && inputNodeDims[1] != inputTensorValues.cols())
  {
    throw std::runtime_error("runONNXInference: feature size doesn't match the input size: inputSize required: " + std::to_string(inputNodeDims[1]*inputNodeDims[2]) + " inputSize provided: " + std::to_string(inputTensorValues.cols()));
  }
 
  if (batchSize != 1 && (inputNodeDims[0] != batchSize || outputNodeDims[0] != batchSize)) 
  {
    throw std::runtime_error("runONNXInference: batch size doesn't match the input or output node size");
  }
 
  // Create input tensor object from data values
  // note: this assumes the model has only 1 input node
  Ort::MemoryInfo memoryInfo = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
  Ort::Value inputTensor = Ort::Value::CreateTensor<float>(memoryInfo, inputTensorValues.data(), inputTensorValues.size(),inputNodeDims.data(), inputNodeDims.size());
  // Double-check that inputTensor is a Tensor
  if (!inputTensor.IsTensor()) 
  {
    throw std::runtime_error("runONNXInference: conversion of input to Tensor failed. ");
  }
  // Score model on input tensors, get back output tensors
  Ort::RunOptions run_options;
  std::vector<Ort::Value> outputTensors =
      m_session->Run(run_options, m_inputNodeNames.data(), &inputTensor,
                     m_inputNodeNames.size(), m_outputNodeNames.data(),
                     m_outputNodeNames.size());
  // Double-check that outputTensors contains Tensors and that the count matches
  // that of output nodes
  if (!outputTensors[0].IsTensor() || (outputTensors.size() != m_outputNodeNames.size())) {
    throw std::runtime_error("runONNXInference: calculation of output failed. ");
  }
  // Get pointer to output tensor float values
  // note: this assumes the model has only 1 output value
  float* outputTensor = outputTensors.front().GetTensorMutableData<float>();
  // Get the output values
  std::vector<std::vector<float>> outputTensorValues(batchSize, std::vector<float>(outputNodeDims[1], -1));
  for (int i = 0; i < outputNodeDims[0]; i++) 
  {
    for (int j = 0; j < ((outputNodeDims.size() > 1) ? outputNodeDims[1] : 1); j++) 
    {
      outputTensorValues[i][j] = outputTensor[i * outputNodeDims[1] + j];
    }
  }
 
  return outputTensorValues;
}

runONNXInference() [2/3]

std::vector< float > OnnxRuntimeBase::runONNXInference ( std::vector< float > &  inputTensorValues ) const

inherited

Definition at line 84 of file OnnxRuntimeBase.cxx.

{
  NetworkBatchInput vectorInput(1, inputTensorValues.size());
  for (size_t i = 0; i < inputTensorValues.size(); i++) {
    vectorInput(0, i) = inputTensorValues[i];
  }
  auto vectorOutput = runONNXInference(vectorInput);
  return vectorOutput[0];
}

runONNXInference() [3/3]

std::vector< std::vector< float > > OnnxRuntimeBase::runONNXInference ( std::vector< std::vector< float > > &  inputTensorValues ) const

inherited

Definition at line 66 of file OnnxRuntimeBase.cxx.

{
  std::vector<std::vector<float> > output;
  if (inputTensorValues.size() == 0) return output;
 
  NetworkBatchInput vectorInput(inputTensorValues.size(), inputTensorValues[0].size());
  for (size_t i = 0; i < inputTensorValues.size(); i++) { 
    for (size_t j = 0; j < inputTensorValues[i].size(); j++) {
      vectorInput(i,j) = inputTensorValues[i][j];
    }
  }
  output = runONNXInference(vectorInput);
  return output;
}

runONNXInferenceMultilayerOutput()

std::map< int, Eigen::MatrixXf > OnnxRuntimeBase::runONNXInferenceMultilayerOutput ( NetworkBatchInput &  inputTensorValues ) const

inherited

Definition at line 162 of file OnnxRuntimeBase.cxx.

{
  const int batchSize = inputTensorValues.rows();
  std::vector<int64_t> inputNodeDims = m_inputNodeDims;
  std::vector<int64_t> outputNodeDims = m_outputNodeDims;
 
  // The first dim node should correspond to the batch size
  // If it is -1, it is dynamic and should be set to the input size
  if (inputNodeDims[0] == -1) 
  {
    inputNodeDims[0] = batchSize;
  }
  if (outputNodeDims[0] == -1) 
  {
    outputNodeDims[0] = batchSize;
  }
 
  if(inputNodeDims[1] != inputTensorValues.cols())
  {
    throw std::runtime_error("runONNXInference: feature size doesn't match the input size: inputSize required: " + std::to_string(inputNodeDims[1]) + " inputSize provided: " + std::to_string(inputTensorValues.cols()));
  }
 
  if (batchSize != 1 &&(inputNodeDims[0] != batchSize || outputNodeDims[0] != batchSize)) 
  {
    throw std::runtime_error("runONNXInference: batch size doesn't match the input or output node size");
  }
  // Create input tensor object from data values
  // note: this assumes the model has only 1 input node
  Ort::MemoryInfo memoryInfo = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
  Ort::Value inputTensor = Ort::Value::CreateTensor<float>(memoryInfo, inputTensorValues.data(), inputTensorValues.size(), inputNodeDims.data(), inputNodeDims.size());
  // Double-check that inputTensor is a Tensor
  if (!inputTensor.IsTensor()) 
  {
    throw std::runtime_error("runONNXInference: conversion of input to Tensor failed. ");
  }
  // Score model on input tensors, get back output tensors
  Ort::RunOptions run_options;
  std::vector<Ort::Value> outputTensors =
      m_session->Run(run_options, m_inputNodeNames.data(), &inputTensor,
                     m_inputNodeNames.size(), m_outputNodeNames.data(),
                     m_outputNodeNames.size());
  // Double-check that outputTensors contains Tensors and that the count matches
  // that of output nodes
  if (!outputTensors[0].IsTensor() || (outputTensors.size() != m_outputNodeNames.size())) {
    throw std::runtime_error("runONNXInference: calculation of output failed. ");
  }
  // Get pointers to output tensor float values
  // note: this assumes the model has multiple output layers
  std::map<int, Eigen::MatrixXf> outputTensorMap;
  size_t numOutputNodes = m_session->GetOutputCount();
  for (size_t i=0; i<numOutputNodes; i++){ // two output layers
 
    // retrieve pointer to output float tenor
    float* output = outputTensors.at(i).GetTensorMutableData<float>();
    Ort::TypeInfo outputTypeInfo = m_session->GetOutputTypeInfo(i);
    auto outputTensorInfo = outputTypeInfo.GetTensorTypeAndShapeInfo();
    // Not all outputNodes have the same shape. Get the new shape.
    // First dimension should be batch size
    outputNodeDims = outputTensorInfo.GetShape();
 
    int nNodes = outputNodeDims.size() > 1 ? outputNodeDims[1] : 1;
    Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> batchMatrix(batchSize, nNodes);
    for (int j = 0; j < batchSize; j++) 
    {
      Eigen::VectorXf vec(nNodes);
      for (int k = 0; k<nNodes; k++) 
      {
        float val = output[j * outputNodeDims[1] + k];
        vec(k) = val;
      }
      batchMatrix.row(j) = vec;
    } // batch
    outputTensorMap[i] = std::move(batchMatrix);
  } // output layers
  return outputTensorMap;
}

setRoadSectors()

StatusCode FPGATrackSimTrackingToolBase::setRoadSectors ( std::vector< std::shared_ptr< const FPGATrackSimRoad >> &  roads )

inherited

Definition at line 11 of file FPGATrackSimTrackingToolBase.cxx.

{
  for (auto& road: roads)
  {
    std::shared_ptr<FPGATrackSimRoad> nonConstRoad = std::const_pointer_cast<FPGATrackSimRoad>(road);
    if (m_useSectors) {
      if(! m_do2ndStage)
        nonConstRoad->setSector(m_FPGATrackSimBank->SectorBank_1st()->findSector(nonConstRoad->getAllHits()));
      else
        nonConstRoad->setSector(m_FPGATrackSimBank->SectorBank_2nd()->findSector(nonConstRoad->getAllHits()));
    }
    else if (m_idealGeoRoads) matchIdealGeoSector(*nonConstRoad);
  }
  // Spacepoint road filter tool. Needed when fitting to spacepoints.
  if (m_useSpacePoints)
  {
    std::vector<std::shared_ptr<const FPGATrackSimRoad>> postfilter_roads;
    ATH_CHECK(m_spRoadFilterTool->filterRoads(roads, postfilter_roads));
    roads = std::move(postfilter_roads);
  }
  return StatusCode::SUCCESS;
}

setTrackParameters()

StatusCode FPGATrackSimNNTrackTool::setTrackParameters	(	std::vector< FPGATrackSimTrack > &	tracks,
		bool	isFirst,
		const FPGATrackSimTrackPars &	min,
		const FPGATrackSimTrackPars &	max
	)

only set this for tracks passing goodness of fit AND overlap removal

Definition at line 66 of file FPGATrackSimNNTrackTool.cxx.

                                                                                                                                                                             {
 
    ATH_MSG_DEBUG("Running NN-based track parameter estimation!");
    std::vector<float> paramNNoutputs;
    if (!m_useParamNN_1st && isFirst) return StatusCode::SUCCESS;
    if (!m_useParamNN_2nd && !isFirst) return StatusCode::SUCCESS;
 
    for (auto &track : tracks) {
      if (!track.passedOR()) continue; 
        std::vector<float> inputTensorValues;
        const std::vector <FPGATrackSimHit>& hits = track.getFPGATrackSimHits();
        bool gotSecondSP = false;
        float tmp_xf;
        float tmp_yf;
        float tmp_zf;
    float tmp_rf;
    float tmp_phif;
    
        for (const auto& hit : hits) {
            if (!hit.isReal()) continue;
 
            // Need to rotate hits
            float xf = hit.getX();
            float yf = hit.getY();
            float zf = hit.getZ();
        float rf = std::sqrt(xf*xf+yf*yf);
        float phif = hit.getGPhi();
        
            // Get average of values for strip hit pairs
            // TODO: this needs to be fixed in the future, for this to work for other cases
            if (hit.isStrip()) {
          if (hit.getHitType() != HitType::spacepoint) { // this is a strip but not a SP!
          if (m_useCartesian) {
                    float xf_scaled = (xf) / (getXScale());
                    float yf_scaled = (yf) / (getYScale());
                    float zf_scaled = (zf) / (getZScale());
            
                    // Get average of two hits for strip hits 
                    inputTensorValues.push_back(xf_scaled);
                    inputTensorValues.push_back(yf_scaled);
                    inputTensorValues.push_back(zf_scaled);
 
          }
          else {
            float rf_scaled = (rf) / (getRScale());
            float phif_scaled = (phif) / (getPhiScale());
            float zf_scaled = (zf) / (getZScale());
            // Get average of two hits for strip hits
                    inputTensorValues.push_back(rf_scaled);
                    inputTensorValues.push_back(phif_scaled);
                    inputTensorValues.push_back(zf_scaled);
          }
          }
          else if (!gotSecondSP) {
        tmp_xf = xf;
        tmp_yf = yf;
        tmp_zf = zf;
        tmp_rf = rf;
        tmp_phif = phif;
        gotSecondSP = true;
          }
          else {
        gotSecondSP = false;
        
        if (m_useCartesian) {
                    float xf_scaled = (xf + tmp_xf) / (2.*getXScale());
                    float yf_scaled = (yf + tmp_yf) / (2.*getYScale());
                    float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
            
                    // Get average of two hits for strip hits 
                    inputTensorValues.push_back(xf_scaled);
                    inputTensorValues.push_back(yf_scaled);
                    inputTensorValues.push_back(zf_scaled);
            
        }
        else {
          float rf_scaled = (rf+tmp_rf) / (2.*getRScale());
          float phif_scaled = (phif+tmp_phif) / (2.*getPhiScale());
          float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
          // Get average of two hits for strip hits
          inputTensorValues.push_back(rf_scaled);
          inputTensorValues.push_back(phif_scaled);
          inputTensorValues.push_back(zf_scaled);
        }
          }
            }
            else {
          if (m_useCartesian) {
                float xf_scaled = (xf) / (getXScale());
                float yf_scaled = (yf) / (getYScale());
                float zf_scaled = (zf) / (getZScale());
                inputTensorValues.push_back(xf_scaled);
                inputTensorValues.push_back(yf_scaled);
                inputTensorValues.push_back(zf_scaled);
          }
          else {
        float rf_scaled = (rf) / (getRScale());
        float phif_scaled = (phif) / (getPhiScale());
        float zf_scaled = (zf) / (getZScale());
        // Get average of two hits for strip hits
        inputTensorValues.push_back(rf_scaled);
        inputTensorValues.push_back(phif_scaled);
        inputTensorValues.push_back(zf_scaled);
          }
            }
        }
 
        if (isFirst){
          if (inputTensorValues.size() < 15) {
            inputTensorValues.resize(15, 0.0f); // Resize to 15 and fill with 0.0f
          }
      
      if (m_doGNNTracking) {
       inputTensorValues.resize(m_nInputsGNN * 3);
      }
    }
    else {
          if (inputTensorValues.size() < 39) {
            inputTensorValues.resize(39, 0.0f); // Resize to 39 and fill with 0.0f
          }
          else if (inputTensorValues.size() > 39) {
            inputTensorValues.resize(39); // Resize to 39 and keep the first e9 elements
          }
    }
    
        if (m_doGNNTracking) {
      inputTensorValues.resize(m_nInputsGNN * 3);
    }
    
    
        if (isFirst) paramNNoutputs = m_paramNN_1st.runONNXInference(inputTensorValues);
        else paramNNoutputs = m_paramNN_2nd.runONNXInference(inputTensorValues);
    
        ATH_MSG_DEBUG("Estimated Track Parameters");
        for (unsigned int i = 0; i < paramNNoutputs.size(); i++) {
      ATH_MSG_DEBUG(paramNNoutputs[i]);
        }
 
    
    double qopt = paramNNoutputs[0]*getQoverPtScale();
    double eta = paramNNoutputs[1]*getEtaScale();
    double phi = paramNNoutputs[2]*getPhiScale();
    double d0 = paramNNoutputs[3]*getD0Scale();
    double z0 = paramNNoutputs[4]*getZ0Scale();
 
 
     if (qopt < min[FPGATrackSimTrackPars::IHIP]) qopt = min[FPGATrackSimTrackPars::IHIP];
     if (qopt > max[FPGATrackSimTrackPars::IHIP]) qopt = max[FPGATrackSimTrackPars::IHIP];
     if (eta < min[FPGATrackSimTrackPars::IETA]) eta = min[FPGATrackSimTrackPars::IETA];
     if (eta > max[FPGATrackSimTrackPars::IETA]) eta = max[FPGATrackSimTrackPars::IETA];
     if (phi < min[FPGATrackSimTrackPars::IPHI]) phi = min[FPGATrackSimTrackPars::IPHI];
     if (phi > max[FPGATrackSimTrackPars::IPHI]) phi = max[FPGATrackSimTrackPars::IPHI];
     if (d0 < min[FPGATrackSimTrackPars::ID0]) d0 = min[FPGATrackSimTrackPars::ID0];
     if (d0 > max[FPGATrackSimTrackPars::ID0]) d0 = max[FPGATrackSimTrackPars::ID0];
     if (z0 < min[FPGATrackSimTrackPars::IZ0]) z0 = min[FPGATrackSimTrackPars::IZ0];
     if (z0 > max[FPGATrackSimTrackPars::IZ0]) z0 = max[FPGATrackSimTrackPars::IZ0];
    
        track.setQOverPt(qopt);
        track.setEta(eta);
        track.setPhi(phi);
        track.setD0(d0);
        track.setZ0(z0);
    }
    return StatusCode::SUCCESS;
}

Member Data Documentation

m_barcode

std::vector<int> FPGATrackSimNNTrackTool::m_barcode

private

Definition at line 87 of file FPGATrackSimNNTrackTool.h.

m_barcodefrac

std::vector<float> FPGATrackSimNNTrackTool::m_barcodefrac

private

Definition at line 86 of file FPGATrackSimNNTrackTool.h.

m_do2ndStage

Gaudi::Property<bool> FPGATrackSimTrackingToolBase::m_do2ndStage {this, "Do2ndStageTrackFit", false, "Do 2nd stage track fit"}

protectedinherited

Definition at line 40 of file FPGATrackSimTrackingToolBase.h.

m_doEtaPatternConsts

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

protectedinherited

Definition at line 35 of file FPGATrackSimTrackingToolBase.h.

m_doGNNTracking

Gaudi::Property<bool> FPGATrackSimNNTrackTool::m_doGNNTracking { this, "doGNNTracking", false, "Flag to turn on GNN Tracking configuration for road-to-track" }

Definition at line 66 of file FPGATrackSimNNTrackTool.h.

m_doRegionalMapping

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

protectedinherited

Definition at line 34 of file FPGATrackSimTrackingToolBase.h.

m_env

std::unique_ptr< Ort::Env > OnnxRuntimeBase::m_env

privateinherited

Definition at line 45 of file OnnxRuntimeBase.h.

m_etamodule

std::vector<unsigned int> FPGATrackSimNNTrackTool::m_etamodule

private

Definition at line 94 of file FPGATrackSimNNTrackTool.h.

m_etawidth

std::vector<unsigned int> FPGATrackSimNNTrackTool::m_etawidth

private

Definition at line 92 of file FPGATrackSimNNTrackTool.h.

m_eventindex

std::vector<int> FPGATrackSimNNTrackTool::m_eventindex

private

Definition at line 88 of file FPGATrackSimNNTrackTool.h.

m_fakeNN_1st

OnnxRuntimeBase FPGATrackSimNNTrackTool::m_fakeNN_1st

private

Definition at line 77 of file FPGATrackSimNNTrackTool.h.

m_fakeNN_2nd

OnnxRuntimeBase FPGATrackSimNNTrackTool::m_fakeNN_2nd

private

Definition at line 78 of file FPGATrackSimNNTrackTool.h.

m_fileName

TString OnnxRuntimeBase::m_fileName

inherited

Definition at line 17 of file OnnxRuntimeBase.h.

m_FPGATrackSimBank

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

protectedinherited

Definition at line 30 of file FPGATrackSimTrackingToolBase.h.

m_FPGATrackSimMapping

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

private

Definition at line 72 of file FPGATrackSimNNTrackTool.h.

m_ID

std::vector<unsigned int> FPGATrackSimNNTrackTool::m_ID

private

Definition at line 96 of file FPGATrackSimNNTrackTool.h.

m_idealGeoRoads

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

protectedinherited

Definition at line 38 of file FPGATrackSimTrackingToolBase.h.

m_input_node_dims

std::vector<int64_t> FPGATrackSimNNTrackTool::m_input_node_dims

private

Definition at line 111 of file FPGATrackSimNNTrackTool.h.

m_input_node_names

std::vector<const char*> FPGATrackSimNNTrackTool::m_input_node_names

private

Definition at line 110 of file FPGATrackSimNNTrackTool.h.

m_inputNodeDims

std::vector<int64_t> OnnxRuntimeBase::m_inputNodeDims

privateinherited

Definition at line 41 of file OnnxRuntimeBase.h.

m_inputNodeNames

std::vector<const char*> OnnxRuntimeBase::m_inputNodeNames

privateinherited

Definition at line 40 of file OnnxRuntimeBase.h.

m_isBarrel

std::vector<unsigned int> FPGATrackSimNNTrackTool::m_isBarrel

private

Definition at line 91 of file FPGATrackSimNNTrackTool.h.

m_isPixel

std::vector<unsigned int> FPGATrackSimNNTrackTool::m_isPixel

private

Definition at line 89 of file FPGATrackSimNNTrackTool.h.

m_isSecondStage

Gaudi::Property<bool> FPGATrackSimTrackingToolBase::m_isSecondStage { this, "isSecondStage", true, "Is this the second stage?" }

protectedinherited

Definition at line 39 of file FPGATrackSimTrackingToolBase.h.

m_layer

std::vector<unsigned int> FPGATrackSimNNTrackTool::m_layer

private

Definition at line 90 of file FPGATrackSimNNTrackTool.h.

m_minNumberOfRealHitsInATrack

Gaudi::Property<unsigned int> FPGATrackSimNNTrackTool::m_minNumberOfRealHitsInATrack { this, "MinNumberOfRealHitsInATrack", 4, "Minimum number of real hits in a track candidate to process" }

Definition at line 65 of file FPGATrackSimNNTrackTool.h.

m_nInputsGNN

Gaudi::Property<int> FPGATrackSimNNTrackTool::m_nInputsGNN { this, "nInputsGNN", 9, "Number of Hit Inputs for NN for GNN configuration. Depends on which model is chosen."}

Definition at line 67 of file FPGATrackSimNNTrackTool.h.

m_output_node_names

std::vector<const char*> FPGATrackSimNNTrackTool::m_output_node_names

private

Definition at line 112 of file FPGATrackSimNNTrackTool.h.

m_outputNodeDims

std::vector<int64_t> OnnxRuntimeBase::m_outputNodeDims

privateinherited

Definition at line 43 of file OnnxRuntimeBase.h.

m_outputNodeNames

std::vector<const char*> OnnxRuntimeBase::m_outputNodeNames

privateinherited

Definition at line 42 of file OnnxRuntimeBase.h.

m_paramNN_1st

OnnxRuntimeBase FPGATrackSimNNTrackTool::m_paramNN_1st

private

Definition at line 75 of file FPGATrackSimNNTrackTool.h.

m_paramNN_2nd

OnnxRuntimeBase FPGATrackSimNNTrackTool::m_paramNN_2nd

private

Definition at line 76 of file FPGATrackSimNNTrackTool.h.

m_phimodule

std::vector<unsigned int> FPGATrackSimNNTrackTool::m_phimodule

private

Definition at line 95 of file FPGATrackSimNNTrackTool.h.

m_phiwidth

std::vector<unsigned int> FPGATrackSimNNTrackTool::m_phiwidth

private

Definition at line 93 of file FPGATrackSimNNTrackTool.h.

m_session

std::unique_ptr<Ort::Session> OnnxRuntimeBase::m_session

privateinherited

ONNX runtime session / model properties.

Definition at line 38 of file OnnxRuntimeBase.h.

m_spRoadFilterTool

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

protectedinherited

Definition at line 32 of file FPGATrackSimTrackingToolBase.h.

m_tHistSvc

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

private

Definition at line 73 of file FPGATrackSimNNTrackTool.h.

m_truth_barcode

std::vector<int> FPGATrackSimNNTrackTool::m_truth_barcode

private

Definition at line 105 of file FPGATrackSimNNTrackTool.h.

m_truth_d0

std::vector<float> FPGATrackSimNNTrackTool::m_truth_d0

private

Definition at line 98 of file FPGATrackSimNNTrackTool.h.

m_truth_eta

std::vector<float> FPGATrackSimNNTrackTool::m_truth_eta

private

Definition at line 101 of file FPGATrackSimNNTrackTool.h.

m_truth_eventindex

std::vector<int> FPGATrackSimNNTrackTool::m_truth_eventindex

private

Definition at line 106 of file FPGATrackSimNNTrackTool.h.

m_truth_pdg

std::vector<float> FPGATrackSimNNTrackTool::m_truth_pdg

private

Definition at line 103 of file FPGATrackSimNNTrackTool.h.

m_truth_phi

std::vector<float> FPGATrackSimNNTrackTool::m_truth_phi

private

Definition at line 102 of file FPGATrackSimNNTrackTool.h.

m_truth_pt

std::vector<float> FPGATrackSimNNTrackTool::m_truth_pt

private

Definition at line 100 of file FPGATrackSimNNTrackTool.h.

m_truth_q

std::vector<int> FPGATrackSimNNTrackTool::m_truth_q

private

Definition at line 104 of file FPGATrackSimNNTrackTool.h.

m_truth_z0

std::vector<float> FPGATrackSimNNTrackTool::m_truth_z0

private

Definition at line 99 of file FPGATrackSimNNTrackTool.h.

m_useCartesian

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

Definition at line 68 of file FPGATrackSimNNTrackTool.h.

m_useParamNN_1st

bool FPGATrackSimNNTrackTool::m_useParamNN_1st = true

private

Definition at line 80 of file FPGATrackSimNNTrackTool.h.

m_useParamNN_2nd

bool FPGATrackSimNNTrackTool::m_useParamNN_2nd = true

private

Definition at line 81 of file FPGATrackSimNNTrackTool.h.

m_useSectors

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

protectedinherited

Definition at line 37 of file FPGATrackSimTrackingToolBase.h.

m_useSpacePoints

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

protectedinherited

Definition at line 36 of file FPGATrackSimTrackingToolBase.h.

m_x

std::vector<float> FPGATrackSimNNTrackTool::m_x

private

Definition at line 83 of file FPGATrackSimNNTrackTool.h.

m_y

std::vector<float> FPGATrackSimNNTrackTool::m_y

private

Definition at line 84 of file FPGATrackSimNNTrackTool.h.

m_z

std::vector<float> FPGATrackSimNNTrackTool::m_z

private

Definition at line 85 of file FPGATrackSimNNTrackTool.h.

---

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

• FPGATrackSimNNTrackTool.h
• FPGATrackSimNNTrackTool.cxx