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	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 (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 ()

Public Attributes
Gaudi::Property< double >	m_chi2_scalefactor { this, "Chi2ScaleFactor", 40 / (1 - 0.1), "Scale factor to use in converting to a chi2, Nominal chi2ndof cut is 40 and we want to use NN>0.0075 (or NN<(1-0.0075)" }
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" }
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	setTrackParameters_1st (FPGATrackSimTrack &track, std::vector< float > inputTensorValues)
void	setTrackParameters_2nd (FPGATrackSimTrack &track, std::vector< float > inputTensorValues)
void	compute_truth (FPGATrackSimTrack &newtrk) const
	OnnxRuntimeBase (TString fileName)
	OnnxRuntimeBase ()

Private Attributes
ServiceHandle< IFPGATrackSimMappingSvc >	m_FPGATrackSimMapping {this, "FPGATrackSimMappingSvc","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 530 of file FPGATrackSimNNTrackTool.cxx.

                                                                      {
  std::vector<FPGATrackSimMultiTruth> mtv;
 
  const FPGATrackSimPlaneMap* planeMap = nullptr;
  if (!m_do2ndStage) planeMap = m_FPGATrackSimMapping->PlaneMap_1st(0);
  else planeMap = m_FPGATrackSimMapping->PlaneMap_2nd(0);
 
  for (unsigned layer = 0; layer < planeMap->getNLogiLayers(); layer++) {
    if (t.getHitMap() & (1 << planeMap->getCoordOffset(layer)))
      continue;  // no hit in this plane
    // 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);
  }
}

getInputNodesDims()

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

inlineinherited

Definition at line 32 of file OnnxRuntimeBase.h.

{return m_inputNodeDims;};

getOutputNodesDims()

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

inlineinherited

Definition at line 33 of file OnnxRuntimeBase.h.

{return m_outputNodeDims;};

getTracks_1st()

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

Definition at line 100 of file FPGATrackSimNNTrackTool.cxx.

                                                                                                                                               {
 
  ATH_CHECK(setRoadSectors(roads));
  int n_track = 0;
 
  // Loop over roads
  for (auto const &iroad : roads) {
 
    double y = iroad->getY();
 
    // Get info on layers with missing hits
    int nMissing = 0;
    layer_bitmask_t missing_mask = 0;
 
    // Just used to get number of layers considered
    const FPGATrackSimPlaneMap *planeMap = m_FPGATrackSimMapping->PlaneMap_1st(iroad->getSubRegion());
 
    // 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());
 
    // 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;
 
    if (m_doGNNTracking) {
      std::vector<std::shared_ptr<const FPGATrackSimHit>> all_pixel_hits;
      std::vector<std::shared_ptr<const FPGATrackSimHit>> all_strip_hits;
      size_t pixelCount = 0;
 
      // Temporarily do not make a road if it has more than 40 hits, there is an issue with some big roads which we do not want to work with right now.
      if (iroad->getNHits() > 40) continue;
 
      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
 
      combs.push_back({}); //Dummy vector such that each road to corresponds to one track combination
    }
    else { 
      combs = getComboIndices(iroad->getNHits_layer());
    }
 
    // Loop over possible combinations for this road
    for (size_t icomb = 0; icomb < combs.size(); icomb++) {
      std::vector<std::shared_ptr<const FPGATrackSimHit>> hit_list;
 
      if (m_doGNNTracking) {
        for (const auto &hit : all_hits) {
          if (hit->isReal()) {
            hit_list.push_back(hit);
          }
        }
 
        if (hit_list.size() < m_minNumberOfRealHitsInATrack) continue;
      }
      else {
        // 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(hit);
            }
          }
        }
 
        // TODO: for now ignore roads with non-real hits, because the network needs all hits as input
        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;
                });
 
      std::vector<float> inputTensorValues;
 
 
      int index = 1;
      bool flipZ = false;
      double rotateAngle = 0;
      bool gotSecondSP = false;
      float tmp_xf;
      float tmp_yf;
      float tmp_zf;
      int missingHits = 10; //For the NN input, we need 5 spacepoints as inputs
 
      // Loop over all hits
      for (const auto &hit : hit_list) {
        if (m_doGNNTracking) {
          if (missingHits <= 0) break;  // Stop looping once enough hits are found
          if(hit->isPixel()) missingHits-= 2; // Each pixel counts as two hits so that strip counts half as much 
          else if(hit->isStrip()) missingHits-= 1; // Since two strip hits is a single spacepoints in the GNN algorithm
        }
        
        // Need to rotate hits
        float x0 = hit->getX();
        float y0 = hit->getY();
        float z0 = hit->getZ();
        if (index == 1) {
          if (z0 < 0)
            flipZ = true;
          rotateAngle = std::atan(x0 / y0);
          if (y0 < 0)
            rotateAngle += M_PI;
        }
 
        float xf = x0 * std::cos(rotateAngle) - y0 * std::sin(rotateAngle);
        float yf = x0 * std::sin(rotateAngle) + y0 * std::cos(rotateAngle);
        float 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 (!gotSecondSP) {
            tmp_xf = xf;
            tmp_yf = yf;
            tmp_zf = zf;
            gotSecondSP = true;
          }
          else {
 
            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++;
            gotSecondSP = false;
          }
        }
        else {
          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++;
        }
      }
 
      if (!m_doGNNTracking) {
        if (inputTensorValues.size() != planeMap->getNLogiLayers()*3) {
          inputTensorValues.resize(planeMap->getNLogiLayers()*3);
        }
      }
 
      std::vector<float> NNoutput = m_fakeNN_1st.runONNXInference(inputTensorValues);
 
      ATH_MSG_DEBUG("NN InputTensorValues:");
      ATH_MSG_DEBUG(inputTensorValues);
      ATH_MSG_DEBUG("NN output:" << NNoutput);
 
      float nn_val = NNoutput[0];
 
      n_track++;
      FPGATrackSimTrack track_cand;
      track_cand.setTrackID(n_track);
      track_cand.setNLayers(planeMap->getNLogiLayers());
      if(m_doGNNTracking) {
        for (const auto &ihit : hit_list) {
          unsigned int layer = ihit->getLayer();
          track_cand.setFPGATrackSimHit(layer, *ihit);
        }
      }
      else {
        for (unsigned ihit = 0; ihit < hit_list.size(); ihit++) {
          track_cand.setFPGATrackSimHit(ihit, *(hit_list[ihit]));
        }
      }
      // Nominal chi2ndof cut is 40 and we want to use NN>0.0075 (or
      // NN<(1-0.0075) Nominal chi2ndof cut is 40 and we want to use NN>0.001
      // (or NN<(1-0.1)
      // the 5 comes from the 5 dof we nominally get from a chi2
      double scale = m_chi2_scalefactor * (track_cand.getNCoords() - track_cand.getNMissing() - 5);
      double chi2 = scale * (1 - nn_val);
      track_cand.setOrigChi2(chi2);
      track_cand.setChi2(chi2);
      tracks.push_back(track_cand);
 
 
      if (m_useParamNN_1st) {
        for (auto& track : tracks) {
          setTrackParameters_1st(track, inputTensorValues);
        }
      }
    }  // loop over combinations
 
  }  // loop over roads
 
  // 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
	)

Definition at line 340 of file FPGATrackSimNNTrackTool.cxx.

                                                                                                                                               {
 
  ATH_CHECK(setRoadSectors(roads));
  int n_track = 0;
 
  // Loop over roads
  for (auto const &iroad : roads) {
 
    double y = iroad->getY();
 
    // Get info on layers with missing hits
    int nMissing = 0;
    layer_bitmask_t missing_mask = 0;
 
    // Just used to get number of layers considered
    const FPGATrackSimPlaneMap *planeMap = m_FPGATrackSimMapping->PlaneMap_2nd(iroad->getSubRegion());
 
    // 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());
 
    // 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++) {
 
      // 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 < 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(hit);
          }
        }
      }
 
      // TODO: for now ignore roads with non-real hits, because the network needs all hits as input
      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;
                });
 
      std::vector<float> inputTensorValues;
 
 
      int index = 1;
      bool flipZ = false;
      double rotateAngle = 0;
      bool gotSecondSP = false;
      float tmp_xf;
      float tmp_yf;
      float tmp_zf;
 
      // 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();
        if (index == 1) {
          if (z0 < 0)
            flipZ = true;
          rotateAngle = std::atan(x0 / y0);
          if (y0 < 0)
            rotateAngle += M_PI;
        }
 
        float xf = x0 * std::cos(rotateAngle) - y0 * std::sin(rotateAngle);
        float yf = x0 * std::sin(rotateAngle) + y0 * std::cos(rotateAngle);
        float 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 (!gotSecondSP) {
            tmp_xf = xf;
            tmp_yf = yf;
            tmp_zf = zf;
            gotSecondSP = true;
          }
          else {
 
            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++;
            gotSecondSP = false;
          }
        }
        else {
          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++;
        }
      }
 
      if (inputTensorValues.size() != planeMap->getNLogiLayers()*3) {
        inputTensorValues.resize(planeMap->getNLogiLayers()*3);
      }
 
      std::vector<float> NNoutput = m_fakeNN_2nd.runONNXInference(inputTensorValues);
 
      ATH_MSG_DEBUG("NN InputTensorValues:");
      ATH_MSG_DEBUG(inputTensorValues);
      ATH_MSG_DEBUG("NN output:" << NNoutput);
 
      float nn_val = NNoutput[0];
 
      n_track++;
      FPGATrackSimTrack track_cand;
      track_cand.setTrackID(n_track);
      track_cand.setNLayers(planeMap->getNLogiLayers());
      for (unsigned ihit = 0; ihit < hit_list.size(); ihit++) {
        track_cand.setFPGATrackSimHit(ihit, *(hit_list[ihit]));
      }
      // Nominal chi2ndof cut is 40 and we want to use NN>0.0075 (or
      // NN<(1-0.0075) Nominal chi2ndof cut is 40 and we want to use NN>0.001
      // (or NN<(1-0.1)
      // the 5 comes from the 5 dof we nominally get from a chi2
      double scale = m_chi2_scalefactor *
                      (track_cand.getNCoords() - track_cand.getNMissing() - 5);
      double chi2 = scale * (1 - nn_val);
      track_cand.setOrigChi2(chi2);
      track_cand.setChi2(chi2);
      tracks.push_back(track_cand);
 
 
      if (m_useParamNN_2nd) {
        for (auto& track : tracks) {
          setTrackParameters_2nd(track, inputTensorValues);
        }
      }
    }  // loop over combinations
 
  }  // loop over roads
 
  // 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 52 of file FPGATrackSimNNTrackTool.h.

{ return 1015.;};

getYScale()

static float FPGATrackSimNNTrackTool::getYScale ( )

inlinestatic

Definition at line 53 of file FPGATrackSimNNTrackTool.h.

{ return 1015.;};

getZScale()

static float FPGATrackSimNNTrackTool::getZScale ( )

inlinestatic

Definition at line 54 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/2]

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

inherited

Definition at line 78 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/2]

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

inherited

Definition at line 66 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];
}

runONNXInferenceMultilayerOutput()

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

inherited

Definition at line 144 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_1st()

void FPGATrackSimNNTrackTool::setTrackParameters_1st ( FPGATrackSimTrack &  track, std::vector< float >  inputTensorValues  )

private

Definition at line 65 of file FPGATrackSimNNTrackTool.cxx.

                                                                                                                 {
 
  ATH_MSG_DEBUG("Running NN-based track parameter estimation!");
  std::vector<float> paramNNoutput = m_paramNN_1st.runONNXInference(inputTensorValues);
 
  ATH_MSG_DEBUG("Estimated Track Parameters");
  for (unsigned int i = 0; i < paramNNoutput.size(); i++) {
    ATH_MSG_DEBUG(paramNNoutput[i]);
  }
 
  track.setQOverPt(paramNNoutput[0]);
  track.setEta(paramNNoutput[1]);
  track.setPhi(paramNNoutput[2]);
  track.setD0(paramNNoutput[3]);
  track.setZ0(paramNNoutput[4]);
}

setTrackParameters_2nd()

void FPGATrackSimNNTrackTool::setTrackParameters_2nd ( FPGATrackSimTrack &  track, std::vector< float >  inputTensorValues  )

private

Definition at line 82 of file FPGATrackSimNNTrackTool.cxx.

                                                                                                                 {
 
  ATH_MSG_DEBUG("Running NN-based track parameter estimation!");
  std::vector<float> paramNNoutput = m_paramNN_2nd.runONNXInference(inputTensorValues);
 
  ATH_MSG_DEBUG("Estimated Track Parameters");
  for (unsigned int i = 0; i < paramNNoutput.size(); i++) {
    ATH_MSG_DEBUG(paramNNoutput[i]);
  }
 
  track.setQOverPt(paramNNoutput[0]);
  track.setEta(paramNNoutput[1]);
  track.setPhi(paramNNoutput[2]);
  track.setD0(paramNNoutput[3]);
  track.setZ0(paramNNoutput[4]);
}

Member Data Documentation

m_barcode

std::vector<int> FPGATrackSimNNTrackTool::m_barcode

private

Definition at line 81 of file FPGATrackSimNNTrackTool.h.

m_barcodefrac

std::vector<float> FPGATrackSimNNTrackTool::m_barcodefrac

private

Definition at line 80 of file FPGATrackSimNNTrackTool.h.

m_chi2_scalefactor

Gaudi::Property<double> FPGATrackSimNNTrackTool::m_chi2_scalefactor { this, "Chi2ScaleFactor", 40 / (1 - 0.1), "Scale factor to use in converting to a chi2, Nominal chi2ndof cut is 40 and we want to use NN>0.0075 (or NN<(1-0.0075)" }

Definition at line 57 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 59 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 44 of file OnnxRuntimeBase.h.

m_etamodule

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

private

Definition at line 88 of file FPGATrackSimNNTrackTool.h.

m_etawidth

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

private

Definition at line 86 of file FPGATrackSimNNTrackTool.h.

m_eventindex

std::vector<int> FPGATrackSimNNTrackTool::m_eventindex

private

Definition at line 82 of file FPGATrackSimNNTrackTool.h.

m_fakeNN_1st

OnnxRuntimeBase FPGATrackSimNNTrackTool::m_fakeNN_1st

private

Definition at line 68 of file FPGATrackSimNNTrackTool.h.

m_fakeNN_2nd

OnnxRuntimeBase FPGATrackSimNNTrackTool::m_fakeNN_2nd

private

Definition at line 69 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","FPGATrackSimMappingSvc"}

private

Definition at line 63 of file FPGATrackSimNNTrackTool.h.

m_ID

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

private

Definition at line 90 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 105 of file FPGATrackSimNNTrackTool.h.

m_input_node_names

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

private

Definition at line 104 of file FPGATrackSimNNTrackTool.h.

m_inputNodeDims

std::vector<int64_t> OnnxRuntimeBase::m_inputNodeDims

privateinherited

Definition at line 40 of file OnnxRuntimeBase.h.

m_inputNodeNames

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

privateinherited

Definition at line 39 of file OnnxRuntimeBase.h.

m_isBarrel

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

private

Definition at line 85 of file FPGATrackSimNNTrackTool.h.

m_isPixel

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

private

Definition at line 83 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 84 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 58 of file FPGATrackSimNNTrackTool.h.

m_output_node_names

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

private

Definition at line 106 of file FPGATrackSimNNTrackTool.h.

m_outputNodeDims

std::vector<int64_t> OnnxRuntimeBase::m_outputNodeDims

privateinherited

Definition at line 42 of file OnnxRuntimeBase.h.

m_outputNodeNames

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

privateinherited

Definition at line 41 of file OnnxRuntimeBase.h.

m_paramNN_1st

OnnxRuntimeBase FPGATrackSimNNTrackTool::m_paramNN_1st

private

Definition at line 66 of file FPGATrackSimNNTrackTool.h.

m_paramNN_2nd

OnnxRuntimeBase FPGATrackSimNNTrackTool::m_paramNN_2nd

private

Definition at line 67 of file FPGATrackSimNNTrackTool.h.

m_phimodule

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

private

Definition at line 89 of file FPGATrackSimNNTrackTool.h.

m_phiwidth

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

private

Definition at line 87 of file FPGATrackSimNNTrackTool.h.

m_session

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

privateinherited

ONNX runtime session / model properties.

Definition at line 37 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 64 of file FPGATrackSimNNTrackTool.h.

m_truth_barcode

std::vector<int> FPGATrackSimNNTrackTool::m_truth_barcode

private

Definition at line 99 of file FPGATrackSimNNTrackTool.h.

m_truth_d0

std::vector<float> FPGATrackSimNNTrackTool::m_truth_d0

private

Definition at line 92 of file FPGATrackSimNNTrackTool.h.

m_truth_eta

std::vector<float> FPGATrackSimNNTrackTool::m_truth_eta

private

Definition at line 95 of file FPGATrackSimNNTrackTool.h.

m_truth_eventindex

std::vector<int> FPGATrackSimNNTrackTool::m_truth_eventindex

private

Definition at line 100 of file FPGATrackSimNNTrackTool.h.

m_truth_pdg

std::vector<float> FPGATrackSimNNTrackTool::m_truth_pdg

private

Definition at line 97 of file FPGATrackSimNNTrackTool.h.

m_truth_phi

std::vector<float> FPGATrackSimNNTrackTool::m_truth_phi

private

Definition at line 96 of file FPGATrackSimNNTrackTool.h.

m_truth_pt

std::vector<float> FPGATrackSimNNTrackTool::m_truth_pt

private

Definition at line 94 of file FPGATrackSimNNTrackTool.h.

m_truth_q

std::vector<int> FPGATrackSimNNTrackTool::m_truth_q

private

Definition at line 98 of file FPGATrackSimNNTrackTool.h.

m_truth_z0

std::vector<float> FPGATrackSimNNTrackTool::m_truth_z0

private

Definition at line 93 of file FPGATrackSimNNTrackTool.h.

m_useParamNN_1st

bool FPGATrackSimNNTrackTool::m_useParamNN_1st = true

private

Definition at line 71 of file FPGATrackSimNNTrackTool.h.

m_useParamNN_2nd

bool FPGATrackSimNNTrackTool::m_useParamNN_2nd = true

private

Definition at line 72 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 77 of file FPGATrackSimNNTrackTool.h.

m_y

std::vector<float> FPGATrackSimNNTrackTool::m_y

private

Definition at line 78 of file FPGATrackSimNNTrackTool.h.

m_z

std::vector<float> FPGATrackSimNNTrackTool::m_z

private

Definition at line 79 of file FPGATrackSimNNTrackTool.h.

---

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

• FPGATrackSimNNTrackTool.h
• FPGATrackSimNNTrackTool.cxx