TrigInDetTrackSeedingTool Class Reference

#include <TrigInDetTrackSeedingTool.h>

Inheritance diagram for TrigInDetTrackSeedingTool:

Collaboration diagram for TrigInDetTrackSeedingTool:

Public Member Functions
	TrigInDetTrackSeedingTool (const std::string &, const std::string &, const IInterface *)
virtual	~TrigInDetTrackSeedingTool ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual TrigInDetTrackSeedingResult	findSeeds (const IRoiDescriptor &, std::vector< TrigInDetTracklet > &, const EventContext &) const override final
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
	DeclareInterfaceID (ITrigInDetTrackSeedingTool, 1, 0)

Protected Types
typedef TrigFTF_GNN_Node	GNN_Node
typedef TrigFTF_GNN_DataStorage	GNN_DataStorage
typedef TrigFTF_GNN_Edge	GNN_Edge
typedef TrigFTF_GNNR3_Node	GNNR3_Node
typedef TrigFTF_GNNR3_DataStorage	GNNR3_DataStorage
typedef TrigFTF_GNNR3_Edge	GNNR3_Edge

Protected Member Functions
void	createGraphNodes (const SpacePointCollection *, std::vector< GNN_Node > &, std::vector< const Trk::SpacePoint * > &, unsigned short, float, float) const
std::pair< int, int >	buildTheGraph (const IRoiDescriptor &, const std::unique_ptr< GNN_DataStorage > &, std::vector< GNN_Edge > &) const
std::pair< int, int >	buildTheGraph (const IRoiDescriptor &, const std::unique_ptr< GNNR3_DataStorage > &, std::vector< GNNR3_Edge > &) const
int	runCCA (int, std::vector< GNN_Edge > &) const
int	runCCA (int, std::vector< GNNR3_Edge > &) const
void	extractSeedsFromTheGraph (int, int, int, std::vector< GNN_Edge > &, std::vector< std::pair< float, std::vector< unsigned int > > > &) const
bool	check_z0_bitmask (const unsigned short &, const float &, const float &, const float &) const
float	estimate_curvature (const std::array< const GNN_Node *, 3 > &) const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
BooleanProperty	m_usePixelSpacePoints {this, "UsePixelSpacePoints", true}
BooleanProperty	m_useSctSpacePoints {this, "UseSctSpacePoints", false}
SG::ReadHandleKey< SpacePointContainer >	m_sctSpacePointsContainerKey {this, "SCT_SP_ContainerName", "ITkStripTrigSpacePoints"}
SG::ReadHandleKey< SpacePointContainer >	m_pixelSpacePointsContainerKey {this, "PixelSP_ContainerName", "ITkPixelTrigSpacePoints"}
ToolHandle< IRegSelTool >	m_regsel_pix { this, "RegSelTool_Pixel", "RegSelTool/RegSelTool_Pixel" }
	region selector tools
ToolHandle< IRegSelTool >	m_regsel_sct { this, "RegSelTool_SCT", "RegSelTool/RegSelTool_SCT" }
BooleanProperty	m_useGPU {this, "UseGPU", false}
ServiceHandle< ITrigInDetAccelerationSvc >	m_accelSvc {this, "TrigAccelerationSvc", ""}
ToolHandle< ITrigL2LayerNumberTool >	m_layerNumberTool {this, "layerNumberTool", "TrigL2LayerNumberToolITk"}
const AtlasDetectorID *	m_atlasId = nullptr
const SCT_ID *	m_sctId = nullptr
const PixelID *	m_pixelId = nullptr
BooleanProperty	m_filter_phi {this, "DoPhiFiltering", true}
BooleanProperty	m_useBeamTilt {this, "UseBeamTilt", false}
BooleanProperty	m_LRTmode {this, "LRTMode",false}
BooleanProperty	m_useML {this, "useML", true}
UnsignedIntegerProperty	m_nMaxPhiSlice {this, "nMaxPhiSlice", 53}
BooleanProperty	m_doubletFilterRZ {this, "Doublet_FilterRZ", true}
BooleanProperty	m_useEtaBinning {this, "UseEtaBinning", true}
BooleanProperty	m_matchBeforeCreate {this, "MatchBeforeCreate", true}
FloatProperty	m_minPt {this, "pTmin", 1000.0}
FloatProperty	m_etaBinOverride {this, "etaBin", 0.0f, "specify non-zero to override eta bin width from connection file (default 0.2 in createLinkingScheme.py)"}
IntegerProperty	m_nMaxEdges {this, "MaxGraphEdges", 2000000}
IntegerProperty	m_nBufferEdges {this, "BufferEdges", 200000}
StringProperty	m_connectionFile {this, "ConnectionFileName", "binTables_ITK_RUN4.txt"}
StringProperty	m_lutFile {this, "MLpredictorLutFileName", "gbts_ml_pixel_barrel_loose.lut"}
BooleanProperty	m_useGPUseedExtraction {this, "UseGPUseedExtraction", true}
BooleanProperty	m_useOldTunings {this, "UseOldTunings", false}
FloatProperty	m_tau_ratio_cut {this, "tau_ratio_cut", 0.007}
float	m_phiSliceWidth = 0.
std::unique_ptr< GNN_FasTrackConnector >	m_connector = nullptr
std::unique_ptr< GNNR3_FasTrackConnector >	m_connector = nullptr
std::vector< TrigInDetSiLayer >	m_layerGeometry
std::unique_ptr< const TrigFTF_GNN_Geometry >	m_geo = nullptr
std::unique_ptr< const TrigFTF_GNNR3_Geometry >	m_geo = nullptr
std::vector< std::array< float, 5 > >	m_mlLUT

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 37 of file TrigInDetTrackSeedingTool.h.

Member Typedef Documentation

GNN_DataStorage

typedef TrigFTF_GNN_DataStorage SeedingToolBase::GNN_DataStorage

protectedinherited

Definition at line 36 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

GNN_Edge

typedef TrigFTF_GNN_Edge SeedingToolBase::GNN_Edge

protectedinherited

Definition at line 37 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

GNN_Node

typedef TrigFTF_GNN_Node SeedingToolBase::GNN_Node

protectedinherited

Definition at line 35 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

GNNR3_DataStorage

typedef TrigFTF_GNNR3_DataStorage SeedingToolBase::GNNR3_DataStorage

protectedinherited

Definition at line 33 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.h.

GNNR3_Edge

typedef TrigFTF_GNNR3_Edge SeedingToolBase::GNNR3_Edge

protectedinherited

Definition at line 34 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.h.

GNNR3_Node

typedef TrigFTF_GNNR3_Node SeedingToolBase::GNNR3_Node

protectedinherited

Definition at line 32 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TrigInDetTrackSeedingTool()

TrigInDetTrackSeedingTool::TrigInDetTrackSeedingTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 27 of file TrigInDetTrackSeedingTool.cxx.

                                                : SeedingToolBase(t,n,p)
{
 
}

~TrigInDetTrackSeedingTool()

virtual TrigInDetTrackSeedingTool::~TrigInDetTrackSeedingTool ( )

inlinevirtual

Definition at line 42 of file TrigInDetTrackSeedingTool.h.

{};

Member Function Documentation

buildTheGraph() [1/2]

std::pair< int, int > SeedingToolBase::buildTheGraph ( const IRoiDescriptor & roi, const std::unique_ptr< GNN_DataStorage > & storage, std::vector< GNN_Edge > & edgeStorage ) const

protectedinherited

Definition at line 98 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

                                                                                                                                                                                 {
 
  
  struct GBTS_SlidingWindow {
 
    GBTS_SlidingWindow() : m_first_it(0), m_deltaPhi(0.0), m_has_nodes(false), m_bin(nullptr) {};
    
    unsigned int m_first_it;// sliding window position
    float m_deltaPhi;       // window half-width;
    bool m_has_nodes;       // active or not
 
    const TrigFTF_GNN_EtaBin* m_bin;//associated eta bin
  };
  
  constexpr float M_2PI = 2.0*M_PI;
  
  const float cut_dphi_max      = m_LRTmode ? 0.07f : 0.012f;
  const float cut_dcurv_max     = m_LRTmode ? 0.015f : 0.001f;
  const float cut_tau_ratio_max = m_LRTmode ? 0.015f : static_cast<float>(m_tau_ratio_cut);
  const float min_z0            = m_LRTmode ? -600.0 : roi.zedMinus();
  const float max_z0            = m_LRTmode ? 600.0 : roi.zedPlus();
  const float min_deltaPhi      = m_LRTmode ? 0.01f : 0.001f;
  const float tau_ratio_precut  = 0.009f;
  
  const float maxOuterRadius    = m_LRTmode ? 1050.0 : 550.0;
 
  const float cut_zMinU = min_z0 + maxOuterRadius*roi.dzdrMinus();
  const float cut_zMaxU = max_z0 + maxOuterRadius*roi.dzdrPlus();
 
  constexpr float ptCoeff = 0.29997*1.9972/2.0;// ~0.3*B/2 - assuming nominal field of 2*T
 
  float tripletPtMin = 0.8f*m_minPt;//correction due to limited pT resolution
  const float pt_scale     = 900.0f/m_minPt;//to re-scale original tunings done for the 900 MeV pT cut
  
  float maxCurv = ptCoeff/tripletPtMin;
 
  float maxKappa_high_eta          = m_LRTmode ? 1.0f*maxCurv : std::sqrt(0.8f)*maxCurv;
  float maxKappa_low_eta           = m_LRTmode ? 1.0f*maxCurv : std::sqrt(0.6f)*maxCurv;
  
  if(!m_useOldTunings && !m_LRTmode) {//new settings for curvature cuts
    maxKappa_high_eta          = 4.75e-4f*pt_scale;
    maxKappa_low_eta           = 3.75e-4f*pt_scale;
  }
 
  const float dphi_coeff                 = m_LRTmode ? 1.0f*maxCurv : 0.68f*maxCurv;
  
  const float minDeltaRadius = 2.0;
    
  float deltaPhi0 = 0.5f*m_phiSliceWidth;//the default sliding window along phi
  
  unsigned int nConnections = 0;
  
  edgeStorage.reserve(m_nMaxEdges);
  
  int nEdges = 0;
 
  float z0_histo_coeff = 16/(max_z0 - min_z0 + 1e-6);//assuming 16-bit z0 bitmask
 
  for(const auto& bg : m_geo->bin_groups()) {//loop over bin groups
    
    TrigFTF_GNN_EtaBin& B1 = storage->getEtaBin(bg.first);
 
    if(B1.empty()) continue;
 
    float rb1 = B1.getMinBinRadius();
    
    const unsigned int lk1 = B1.m_layerKey;
 
    //prepare a sliding window for each bin2 in the group 
 
    std::vector<GBTS_SlidingWindow> vSLW;
 
    vSLW.resize(bg.second.size());//initialization using default ctor
 
    int win_idx = 0;
    
    for(const auto& b2_idx : bg.second) { //loop over n2 eta-bins in L2 layers
 
      const TrigFTF_GNN_EtaBin& B2 = storage->getEtaBin(b2_idx);
 
      if(B2.empty()) {
        win_idx++;
        continue;
      }
      
      float rb2 = B2.getMaxBinRadius();
 
      float deltaPhi = deltaPhi0;//the default
      
      if(m_useEtaBinning) { //override the default window width
        float abs_dr = std::fabs(rb2-rb1);
        if (m_useOldTunings) {
          deltaPhi = min_deltaPhi + dphi_coeff*abs_dr;
        }
        else {
          if(abs_dr < 60.0) {
            deltaPhi = 0.002f + 4.33e-4f*pt_scale*abs_dr;
          } else {
            deltaPhi = 0.015f + 2.2e-4f*pt_scale*abs_dr;
          }
        }
      }
 
      vSLW[win_idx].m_bin = &B2;
      vSLW[win_idx].m_has_nodes = true;
      vSLW[win_idx].m_deltaPhi = deltaPhi;
      win_idx++;
    }
 
    for(unsigned int n1Idx = 0;n1Idx<B1.m_vn.size();n1Idx++) {//in GBTSv3 the outer loop goes over n1 nodes in the Layer 1 bin
 
      B1.m_vFirstEdge[n1Idx] = nEdges;//initialization using the top watermark of the edge storage
 
      unsigned short num_created_edges = 0;//the counter for the incoming graph edges created for n1
 
      bool is_connected = false;
 
      std::array<unsigned char, 16> z0_histo = {};
  
      const std::array<float, 5>& n1pars = B1.m_params[n1Idx];
 
      float phi1 = n1pars[2];
      float r1 = n1pars[3];
      float z1 = n1pars[4];
 
      for(unsigned int winIdx = 0; winIdx < vSLW.size(); winIdx++) {//the intermediate loop over sliding windows
 
        GBTS_SlidingWindow& slw = vSLW[winIdx];
 
        if (!slw.m_has_nodes) continue;
 
        const TrigFTF_GNN_EtaBin& B2 = *slw.m_bin;
 
        float deltaPhi = slw.m_deltaPhi;
      
        //sliding window phi1 +/- deltaPhi
      
        float minPhi = phi1 - deltaPhi;
        float maxPhi = phi1 + deltaPhi;
      
    for(unsigned int n2PhiIdx = slw.m_first_it; n2PhiIdx<B2.m_vPhiNodes.size();n2PhiIdx++) {//the inner loop over n2 nodes using sliding window
    
      float phi2 = B2.m_vPhiNodes[n2PhiIdx].first;
 
      if(phi2 < minPhi) {
            slw.m_first_it = n2PhiIdx; //update the window position
            continue;
          }
          if(phi2 > maxPhi) break; //break and go to the next window
      
      unsigned int n2Idx = B2.m_vPhiNodes[n2PhiIdx].second;
 
      unsigned short node_info = B2.m_vIsConnected[n2Idx];
 
      if ((lk1 == 80000) && (node_info == 0) ) continue;//skip isolated nodes as their incoming edges lead to nowhere
 
      unsigned int   n2_first_edge = B2.m_vFirstEdge[n2Idx];
          unsigned short n2_num_edges  = B2.m_vNumEdges[n2Idx];
      unsigned int   n2_last_edge  = n2_first_edge + n2_num_edges;
      
      const std::array<float, 5>& n2pars = B2.m_params[n2Idx];
    
      float r2 = n2pars[3];
      
      float dr = r2 - r1;
    
      if(dr < minDeltaRadius) {
        continue;
      }
    
      float z2 = n2pars[4];
 
      float dz = z2 - z1;
      float tau = dz/dr;
      float ftau = std::fabs(tau);
      if (ftau > 36.0) {
        continue;
      }
    
      if(ftau < n1pars[0]) continue;
      if(ftau > n1pars[1]) continue;
 
      if(ftau < n2pars[0]) continue;
      if(ftau > n2pars[1]) continue;
 
      float z0 = z1 - r1*tau;
 
      if (lk1 == 80000) {//check against non-empty z0 histogram
        
        if ( !check_z0_bitmask(node_info, z0, min_z0, z0_histo_coeff) ) {
 
          continue;
 
        }
        
      }
      
      if (m_doubletFilterRZ) {
        
        if(z0 < min_z0 || z0 > max_z0) continue;
      
        float zouter = z0 + maxOuterRadius*tau;
      
        if(zouter < cut_zMinU || zouter > cut_zMaxU) continue;                
      }
        
      float curv = (phi2-phi1)/dr;
      float abs_curv = std::abs(curv);
        
      if(ftau < 4.0) {//eta = 2.1
        if(abs_curv > maxKappa_low_eta) {
          continue;
        }
      }
      else {
        if(abs_curv > maxKappa_high_eta) {
          continue;
        }
      }
 
      float exp_eta = std::sqrt(1.f+tau*tau) - tau;
        
      if (m_matchBeforeCreate && (lk1 == 80000 || lk1 == 81000) ) {//match edge candidate against edges incoming to n2
 
        bool isGood = n2_num_edges <= 2;//we must have enough incoming edges to decide
        
        if(!isGood) {
 
          float uat_1 = 1.0f/exp_eta;
            
          for(unsigned int n2_in_idx = n2_first_edge; n2_in_idx < n2_last_edge; n2_in_idx++) {
            
        float tau2 = edgeStorage.at(n2_in_idx).m_p[0]; 
        float tau_ratio = tau2*uat_1 - 1.0f;
        
        if(std::fabs(tau_ratio) > tau_ratio_precut){//bad match
          continue;
        }
        isGood = true;//good match found
        break;
          }
        }
        
        if(!isGood) {//no match found, skip creating [n1 <- n2] edge
          continue;
        }
      }
      
      float dPhi2 = curv*r2;
      float dPhi1 = curv*r1;
    
      if(nEdges < m_nMaxEdges) {
      
        edgeStorage.emplace_back(B1.m_vn[n1Idx], B2.m_vn[n2Idx], exp_eta, curv, phi1 + dPhi1);
 
        num_created_edges++;
          
        int outEdgeIdx = nEdges;
      
        float uat_2  = 1.f/exp_eta;
        float Phi2  = phi2 + dPhi2;
        float curv2 = curv;
        
        for(unsigned int inEdgeIdx = n2_first_edge; inEdgeIdx < n2_last_edge; inEdgeIdx++) {//looking for neighbours of the new edge
          
          TrigFTF_GNN_Edge* pS = &(edgeStorage.at(inEdgeIdx));
          
          if(pS->m_nNei >= N_SEG_CONNS) continue;
          
          float tau_ratio = pS->m_p[0]*uat_2 - 1.0f;
          
          if(std::abs(tau_ratio) > cut_tau_ratio_max){//bad match
        continue;
          }
          
          float dPhi =  Phi2 - pS->m_p[2];
          
          if(dPhi<-M_PI) dPhi += M_2PI;
          else if(dPhi>M_PI) dPhi -= M_2PI;
          
          if(std::abs(dPhi) > cut_dphi_max) {
        continue;
          }
            
          float dcurv = curv2 - pS->m_p[1];
            
          if(dcurv < -cut_dcurv_max || dcurv > cut_dcurv_max) {
        continue;
          }
            
          pS->m_vNei[pS->m_nNei++] = outEdgeIdx;
 
          is_connected = true;//there is at least one good match
 
          //edge confirmed - update z0 histogram
 
          int z0_bin_index = z0_histo_coeff*(z0 - min_z0);
 
          ++z0_histo[z0_bin_index];
          
          nConnections++;
        
        }
        nEdges++;       
      }
    } //loop over n2 (outer) nodes inside a sliding window on n2 bin
      } //loop over sliding windows associated with n2 bins
 
      //updating the n1 node attributes
      
      B1.m_vNumEdges[n1Idx] = num_created_edges;
 
      if (is_connected) {
 
        unsigned short z0_bitmask = 0x0;
 
        for(unsigned int bIdx = 0; bIdx < 16; bIdx++) {
 
          if (z0_histo[bIdx] == 0) continue;
 
          z0_bitmask |= (1 << bIdx);
        }
 
        B1.m_vIsConnected[n1Idx] = z0_bitmask;//non-zero mask indicates that there is at least one connected edge
      }
      
    } //loop over n1 (inner) nodes
  } //loop over bin groups: a single n1 bin and multiple n2 bins
 
  if(nEdges >= m_nMaxEdges) {
    ATH_MSG_WARNING("Maximum number of graph edges exceeded - possible efficiency loss "<< nEdges);
  }
 
  return std::make_pair(nEdges, nConnections);
}

buildTheGraph() [2/2]

std::pair< int, int > SeedingToolBase::buildTheGraph ( const IRoiDescriptor & roi, const std::unique_ptr< GNNR3_DataStorage > & storage, std::vector< GNNR3_Edge > & edgeStorage ) const

protectedinherited

Definition at line 71 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.cxx.

                                                                                                                                                                                     {
 
  const float M_2PI = 2.0*M_PI;
  
  const float cut_dphi_max      = m_LRTmode ? 0.07 : 0.012;
  const float cut_dcurv_max     = m_LRTmode ? 0.015 : 0.001;
  const float cut_tau_ratio_max = m_LRTmode ? 0.015 : 0.007;
  const float min_z0            = m_LRTmode ? -600.0 : roi.zedMinus();
  const float max_z0            = m_LRTmode ? 600.0 : roi.zedPlus();
  const float min_deltaPhi      = m_LRTmode ? 0.01f : 0.001f;
  
  const float maxOuterRadius    = m_LRTmode ? 1050.0 : 550.0;
 
  const float cut_zMinU = min_z0 + maxOuterRadius*roi.dzdrMinus();
  const float cut_zMaxU = max_z0 + maxOuterRadius*roi.dzdrPlus();
 
  const float ptCoeff = 0.29997*1.9972/2.0;// ~0.3*B/2 - assuming nominal field of 2*T
 
  float tripletPtMin = 0.8*m_minPt;//correction due to limited pT resolution
  
  float maxCurv = ptCoeff/tripletPtMin;
 
  const float maxKappa_high_eta          = m_LRTmode ? 1.0*maxCurv : std::sqrt(0.8)*maxCurv;
  const float maxKappa_low_eta           = m_LRTmode ? 1.0*maxCurv : std::sqrt(0.6)*maxCurv;
  const float dphi_coeff                 = m_LRTmode ? 1.0*maxCurv : 0.68*maxCurv;
  
  const float minDeltaRadius = 2.0;
    
  float deltaPhi = 0.5f*m_phiSliceWidth;//the default sliding window along phi
 
  unsigned int nConnections = 0;
  
  edgeStorage.reserve(m_nMaxEdges);
  
  int nEdges = 0;
 
  for(const auto& bg : m_geo->bin_groups()) {//loop over bin groups
    
    TrigFTF_GNNR3_EtaBin& B1 = storage->getEtaBin(bg.first);
 
    if(B1.empty()) continue;
 
    float rb1 = B1.getMinBinRadius();
 
    for(const auto& b2_idx : bg.second) {
 
      const TrigFTF_GNNR3_EtaBin& B2 = storage->getEtaBin(b2_idx);
 
      if(B2.empty()) continue;
      
      float rb2 = B2.getMaxBinRadius();
    
      if(m_useEtaBinning) {
    deltaPhi = min_deltaPhi + dphi_coeff*std::fabs(rb2-rb1);    
      }
 
      unsigned int first_it = 0;
 
      for(unsigned int n1Idx = 0;n1Idx<B1.m_vn.size();n1Idx++) {//loop over nodes in Layer 1
 
    std::vector<unsigned int>& v1In = B1.m_in[n1Idx];   
 
    if(v1In.size() >= MAX_SEG_PER_NODE) continue;
      
    const std::array<float, 5>& n1pars = B1.m_params[n1Idx];
 
    float phi1 = n1pars[2];
    float r1 = n1pars[3];
    float z1 = n1pars[4];
      
    //sliding window phi1 +/- deltaPhi
      
    float minPhi = phi1 - deltaPhi;
    float maxPhi = phi1 + deltaPhi;
      
    for(unsigned int n2PhiIdx = first_it; n2PhiIdx<B2.m_vPhiNodes.size();n2PhiIdx++) {//sliding window over nodes in Layer 2
    
      float phi2 = B2.m_vPhiNodes[n2PhiIdx].first;
    
      if(phi2 < minPhi) {
        first_it = n2PhiIdx;
        continue;
      }
      if(phi2 > maxPhi) break;
    
      unsigned int n2Idx = B2.m_vPhiNodes[n2PhiIdx].second;
    
      const std::vector<unsigned int>& v2In = B2.m_in[n2Idx];
        
      if(v2In.size() >= MAX_SEG_PER_NODE) continue;
        
      const std::array<float, 5>& n2pars = B2.m_params[n2Idx];
    
      float r2 = n2pars[3];
      
      float dr = r2 - r1;
    
      if(dr < minDeltaRadius) {
        continue;
      }
    
      float z2 = n2pars[4];
 
      float dz = z2 - z1;
      float tau = dz/dr;
      float ftau = std::fabs(tau);
      if (ftau > 36.0) {
        continue;
      }
    
      if(ftau < n1pars[0]) continue;
      if(ftau > n1pars[1]) continue;
 
      if(ftau < n2pars[0]) continue;
      if(ftau > n2pars[1]) continue;
        
      if (m_doubletFilterRZ) {
          
        float z0 = z1 - r1*tau;
      
        if(z0 < min_z0 || z0 > max_z0) continue;
      
        float zouter = z0 + maxOuterRadius*tau;
      
        if(zouter < cut_zMinU || zouter > cut_zMaxU) continue;                
      }
        
      float curv = (phi2-phi1)/dr;
      float abs_curv = std::abs(curv);
        
      if(ftau < 4.0) {//eta = 2.1
        if(abs_curv > maxKappa_low_eta) {
          continue;
        }
      }
      else {
        if(abs_curv > maxKappa_high_eta) {
          continue;
        }
      }
 
      float exp_eta = std::sqrt(1+tau*tau)-tau;
      
      if (m_matchBeforeCreate) {//match edge candidate against edges incoming to n2
 
        bool isGood = v2In.size() <= 2;//we must have enough incoming edges to decide
 
        if(!isGood) {
 
          float uat_1 = 1.0f/exp_eta;
            
          for(const auto& n2_in_idx : v2In) {
            
        float tau2 = edgeStorage.at(n2_in_idx).m_p[0]; 
        float tau_ratio = tau2*uat_1 - 1.0f;
        
        if(std::fabs(tau_ratio) > cut_tau_ratio_max){//bad match
          continue;
        }
        isGood = true;//good match found
        break;
          }
        }
        
        if(!isGood) {//no match found, skip creating [n1 <- n2] edge
          continue;
        }
      }
      
      float dPhi2 = curv*r2;
      float dPhi1 = curv*r1;
    
      if(nEdges < m_nMaxEdges) {
      
        edgeStorage.emplace_back(B1.m_vn[n1Idx], B2.m_vn[n2Idx], exp_eta, curv, phi1 + dPhi1);
        
        if(v1In.size() < MAX_SEG_PER_NODE) v1In.push_back(nEdges);
          
        int outEdgeIdx = nEdges;
      
        float uat_2  = 1/exp_eta;
        float Phi2  = phi2 + dPhi2;
        float curv2 = curv;
        
        for(const auto& inEdgeIdx : v2In) {//looking for neighbours of the new edge
        
          TrigFTF_GNNR3_Edge* pS = &(edgeStorage.at(inEdgeIdx));
          
          if(pS->m_nNei >= N_SEG_CONNS) continue;
        
          float tau_ratio = pS->m_p[0]*uat_2 - 1.0f;
          
          if(std::abs(tau_ratio) > cut_tau_ratio_max){//bad match
        continue;
          }
          
          float dPhi =  Phi2 - pS->m_p[2];
          
          if(dPhi<-M_PI) dPhi += M_2PI;
          else if(dPhi>M_PI) dPhi -= M_2PI;
          
          if(dPhi < -cut_dphi_max || dPhi > cut_dphi_max) {
        continue;
          }
            
          float dcurv = curv2 - pS->m_p[1];
            
          if(dcurv < -cut_dcurv_max || dcurv > cut_dcurv_max) {
        continue;
          }
            
          pS->m_vNei[pS->m_nNei++] = outEdgeIdx;
        
          nConnections++;
        
        }
        nEdges++;       
      }
    } //loop over n2 (outer) nodes
      } //loop over n1 (inner) nodes
    } //loop over bins in Layer 2
  } //loop over bin groups
 
  return std::make_pair(nEdges, nConnections);
}

check_z0_bitmask()

bool SeedingToolBase::check_z0_bitmask ( const unsigned short & z0_bitmask, const float & z0, const float & min_z0, const float & z0_histo_coeff ) const

protectedinherited

Definition at line 752 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

                                                                                                                                                {
 
  if (z0_bitmask == 0) return true;
 
  float dz = z0 - min_z0; 
  int z0_bin_index = z0_histo_coeff*dz;
 
  if ((z0_bitmask >> z0_bin_index) & 1) return true;
 
  //check adjacent bins as well
            
  const float z0_resolution = 2.5;
  
  float dzm = dz - z0_resolution;
 
  int next_bin  = z0_histo_coeff*dzm;
 
  if (next_bin >= 0 && next_bin != z0_bin_index) {
      
      if ((z0_bitmask >> next_bin) & 1) return true;
 
  }               
 
  float dzp = dz + z0_resolution;
 
  next_bin  = z0_histo_coeff*dzp;
 
  if (next_bin < 16 && next_bin != z0_bin_index) {
            
    if ((z0_bitmask >> next_bin) & 1) return true;
      
  }
    
  return false;
}

createGraphNodes()

void TrigInDetTrackSeedingTool::createGraphNodes ( const SpacePointCollection * spColl, std::vector< GNN_Node > & tmpColl, std::vector< const Trk::SpacePoint * > & vSP, unsigned short layer, float shift_x, float shift_y ) const

protected

Definition at line 580 of file TrigInDetTrackSeedingTool.cxx.

                                                                                                                                                                                                                 {
  
  tmpColl.resize(spColl->size(), GNN_Node(layer));//all nodes belong to the same layer
  
  int idx = 0;
  int init_size = vSP.size();
  for(const auto sp : *spColl) {
    const auto& pos = sp->globalPosition();
    vSP.emplace_back(sp);
    float xs = pos.x() - shift_x;
    float ys = pos.y() - shift_y;
    float zs = pos.z();
    tmpColl[idx].m_x = xs;
    tmpColl[idx].m_y = ys;
    tmpColl[idx].m_z = zs;
    tmpColl[idx].m_r = std::sqrt(xs*xs + ys*ys);
    tmpColl[idx].m_phi = std::atan2(ys,xs);
    tmpColl[idx].m_idx = init_size + idx;
 
    const InDet::PixelCluster* pCL = dynamic_cast<const InDet::PixelCluster*>(sp->clusterList().first);
    if(pCL != nullptr){
      tmpColl[idx].m_pcw = pCL->width().z();
      tmpColl[idx].m_locPosY = pCL->localPosition().y();
    }
 
    idx++;
  }
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

DeclareInterfaceID()

ITrigInDetTrackSeedingTool::DeclareInterfaceID ( ITrigInDetTrackSeedingTool , 1 , 0  )

inherited

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

estimate_curvature()

float SeedingToolBase::estimate_curvature ( const std::array< const GNN_Node *, 3 > & sps ) const

protectedinherited

Definition at line 789 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

                                                                                       {
 
  //conformal mapping with the center at the last spacepoint
 
  float u[2], v[2];
 
  float x0 = sps[2]->x();
  float y0 = sps[2]->y();
 
  float r0 = sps[2]->r();
  
  float cosA = x0/r0;
  
  float sinA = y0/r0;
 
  
  for(unsigned int k=0;k<2;k++) {
 
    float dx = sps[k]->x() - x0;
 
    float dy = sps[k]->y() - y0;
 
    float r2_inv = 1.0/(dx*dx+dy*dy);
    
    float xn = dx*cosA + dy*sinA;
    
    float yn =-dx*sinA + dy*cosA;
 
    u[k] = xn*r2_inv;
    v[k] = yn*r2_inv;    
  }
 
  float du = u[0] - u[1];
 
  if(du==0.0) return 0.0;
  
  float A = (v[0] - v[1])/du;
 
  float B = v[1] - A*u[1];
  
  float R = std::sqrt(1 + A*A)/B; //signed radius in mm
 
  return 1000.0/R; //inverse meters
  
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extractSeedsFromTheGraph()

void SeedingToolBase::extractSeedsFromTheGraph ( int maxLevel, int nEdges, int nHits, std::vector< GNN_Edge > & edgeStorage, std::vector< std::pair< float, std::vector< unsigned int > > > & vOutputSeeds ) const

protectedinherited

Definition at line 502 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

                                                                                                                                                                                              {
 
  const float edge_mask_min_eta      = 1.5;
  const float hit_share_threshold    = 0.49;
  const float max_eta_for_seed_split = 0.6;
  const float max_inv_rad_diff       = 0.7e-2;//in inverse meters
 
  int minLevel = 3;//a triplet + 2 confirmation
 
  if(m_LRTmode) {
    minLevel = 2;//a triplet + 1 confirmation
  }
 
  if(maxLevel < minLevel) return;
  
  std::vector<GNN_Edge*> vSeeds;
 
  vSeeds.reserve(nEdges/2);
 
  for(int edgeIndex = 0; edgeIndex < nEdges; edgeIndex++) {
    
    GNN_Edge* pS = &(edgeStorage.at(edgeIndex));
    
    if(pS->m_level < minLevel) continue;
    
    vSeeds.push_back(pS);
  }
  
  if(vSeeds.empty()) return;
  
  std::sort(vSeeds.begin(), vSeeds.end(), GNN_Edge::CompareLevel());
    
  //backtracking
 
  std::vector<std::tuple<float, int, std::vector<const GNN_Node*>, int > > vSeedCandidates;
 
  vSeedCandidates.reserve(vSeeds.size());
 
  std::vector<std::pair<float, unsigned int> > vArgSort;
 
  vArgSort.reserve(vSeeds.size());
 
  unsigned int seed_counter = 0;
  
  auto tFilter = std::make_unique<TrigFTF_GNN_TrackingFilter>(m_layerGeometry, edgeStorage);
 
  for(auto pS : vSeeds) {
 
    if(pS->m_level == -1) continue;
 
    TrigFTF_GNN_EdgeState rs(false);
 
    tFilter->followTrack(pS, rs);
 
    if(!rs.m_initialized) {
      continue;
    }
 
    if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
 
    float seed_eta = std::abs(-std::log(pS->m_p[0]));
    
    std::vector<const GNN_Node*> vN;
 
    for(std::vector<GNN_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
 
      if (seed_eta > edge_mask_min_eta) {
    (*sIt)->m_level = -1;//mark as collected
      }
      
      if(sIt == rs.m_vs.rbegin()) {
    vN.push_back((*sIt)->m_n1);
      }
 
      vN.push_back((*sIt)->m_n2);
        
    }
 
    if(vN.size()<3) continue;
 
    unsigned int orig_seed_size = vN.size();
 
    float orig_seed_quality = -rs.m_J/orig_seed_size;
    
    int seed_split_flag = (seed_eta < max_eta_for_seed_split) && (orig_seed_size <= 5) ? 1 : 0;
 
    if (seed_split_flag == 1) {//split the seed by dropping spacepoints
      
      std::array< std::array<const GNN_Node*, 3>, 3> triplets;//2 "drop-outs" and the original seed candidate
      
      std::array<float, 3> inv_rads;//triplet parameter estimate
 
      triplets[0] = {vN[0], vN[orig_seed_size/2], vN[orig_seed_size-1]};
 
      std::vector<const GNN_Node*> drop_out1 = {vN.begin()+1, vN.end()}; //all but the first one
      
      triplets[1] = {drop_out1[0], drop_out1[(orig_seed_size-1)/2], drop_out1[orig_seed_size-2]};
      
      std::vector<const GNN_Node*> drop_out2;
 
      drop_out2.reserve(orig_seed_size-1);
      
      for(unsigned int k = 0; k < orig_seed_size; k++) {
 
        if (k == orig_seed_size/2) continue;//drop the middle SP in the original seed
        
        drop_out2.emplace_back(vN[k]);
      }
 
      triplets[2] = {drop_out2[0], drop_out2[(orig_seed_size-1)/2], drop_out2[orig_seed_size-2]};
 
      for (unsigned int k = 0; k < inv_rads.size(); k++) {
 
        inv_rads[k] = estimate_curvature(triplets[k]);
    
      }
 
      float diffs[3] = {std::abs(inv_rads[1] - inv_rads[0]), std::abs(inv_rads[2] - inv_rads[0]), std::abs(inv_rads[2] - inv_rads[1])};
 
      bool confirmed = diffs[0] < max_inv_rad_diff && diffs[1] < max_inv_rad_diff && diffs[2] < max_inv_rad_diff;
 
      if (confirmed) {
        seed_split_flag = 0;//reset the flag
      }
      
    }
        
    vSeedCandidates.emplace_back(orig_seed_quality, 0, vN, seed_split_flag);
    
    vArgSort.emplace_back(orig_seed_quality, seed_counter);
 
    ++seed_counter;
    
  }
  
  //clone removal code goes below ...
 
  std::sort(vArgSort.begin(), vArgSort.end());
  
  std::vector<int> H2T(nHits + 1, 0);//hit to track associations
 
  int trackId = 0;
 
  
  for(const auto& ags : vArgSort) {
 
    const auto& seed = vSeedCandidates[ags.second];
    
    trackId++;
    
    for(const auto& h : std::get<2>(seed) ) {//loop over spacepoints indices
    
      unsigned int hit_id = h->sp_idx() + 1;
      
      int tid     = H2T[hit_id];
      
      if(tid == 0 || tid > trackId) {//unused hit or used by a lesser track
    
    H2T[hit_id] = trackId;//overwrite
    
      }
    }      
  }
 
  unsigned int trackIdx = 0;
 
  for(const auto& ags : vArgSort) {
 
    const auto& seed = std::get<2>(vSeedCandidates[ags.second]);
    
    int nTotal = seed.size();
    
    int nOther = 0;
    
    int trackId = trackIdx + 1;
 
    ++trackIdx;
 
    for(const auto& h : seed ) {
 
      unsigned int hit_id = h->sp_idx() + 1;
      
      int tid = H2T[hit_id];
 
    if(tid != trackId) {//taken by a better candidate
          nOther++;
    }
    }
 
    if (nOther > hit_share_threshold*nTotal) {
        std::get<1>(vSeedCandidates[ags.second]) = -1;//reject
    }
 
  }
 
  vOutputSeeds.reserve(vSeedCandidates.size());
  
  //drop the clones and split seeds if need be
 
  for (const auto& seed : vSeedCandidates) {
 
    if (std::get<1>(seed) != 0) continue;//identified as a clone of a better candidate
 
    const auto& vN = std::get<2>(seed);
 
    if (std::get<3>(seed) == 0) {
      
      //add seed to output
 
      std::vector<unsigned int> vSpIdx;
      
      vSpIdx.resize(vN.size());
    
      for(unsigned int k = 0; k < vSpIdx.size(); k++) {
    vSpIdx[k] = vN[k]->sp_idx();
      }
 
      vOutputSeeds.emplace_back(std::get<0>(seed), vSpIdx);
 
      continue;
 
    }
 
    //seed split into "drop-out" seeds 
 
    unsigned int seedSize = vN.size();
        
    std::array<std::size_t, 2> indices2drop = {0, seedSize / 2ul};//the first and the middle
 
    for(const auto& skipIdx : indices2drop) {
        
      std::vector<unsigned int> new_seed;
 
      new_seed.reserve(seedSize-1);
        
      for (unsigned int k = 0; k < seedSize; k++) {
          
    if (k ==  skipIdx) continue;
          
    new_seed.emplace_back(vN[k]->sp_idx());
         
      }
 
      vOutputSeeds.emplace_back(std::get<0>(seed), new_seed);
        
    }
  }
  
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode TrigInDetTrackSeedingTool::finalize ( )

overridevirtual

Reimplemented from SeedingToolBase.

Definition at line 68 of file TrigInDetTrackSeedingTool.cxx.

                                               {
  return SeedingToolBase::finalize();
}

findSeeds()

TrigInDetTrackSeedingResult TrigInDetTrackSeedingTool::findSeeds ( const IRoiDescriptor & internalRoI, std::vector< TrigInDetTracklet > & output, const EventContext & ctx ) const

finaloverridevirtual

Implements ITrigInDetTrackSeedingTool.

Definition at line 73 of file TrigInDetTrackSeedingTool.cxx.

                                                                                                                                                                       {
 
  TrigInDetTrackSeedingResult seedStats;
  
  output.clear();
 
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };  
  const Amg::Vector3D &vertex = beamSpotHandle->beamPos();
  float shift_x = vertex.x() - beamSpotHandle->beamTilt(0)*vertex.z();
  float shift_y = vertex.y() - beamSpotHandle->beamTilt(1)*vertex.z();
 
  std::unique_ptr<GNN_DataStorage> storage = std::make_unique<GNN_DataStorage>(*m_geo, m_mlLUT);
  
  int nPixels = 0;
  int nStrips = 0;
 
  const SpacePointContainer* sctSpacePointsContainer = nullptr;
  const SpacePointContainer* pixelSpacePointsContainer = nullptr;
 
  std::map<short, std::vector<IdentifierHash> > detIdMap;//relates global detector layer ID to constituent detector elements
 
  if (m_useSctSpacePoints) {
    
    SG::ReadHandle<SpacePointContainer> sctHandle(m_sctSpacePointsContainerKey, ctx);
 
    if(!sctHandle.isValid()) {
      ATH_MSG_WARNING("Invalid Strip Spacepoints handle: "<<sctHandle);
      return seedStats;
      
    }
    
    sctSpacePointsContainer = sctHandle.ptr();
 
    std::vector<IdentifierHash> listOfSctIds;
    m_regsel_sct->lookup(ctx)->HashIDList( internalRoI, listOfSctIds );
 
    const std::vector<short>* h2l = m_layerNumberTool->sctLayers();
    
    for(const auto& hashId : listOfSctIds) {
      
      short layerIndex = h2l->at(static_cast<int>(hashId));
 
      auto it = detIdMap.find(layerIndex);
      if(it != detIdMap.end()) (*it).second.push_back(hashId);
      else {
        std::vector<IdentifierHash> v = {hashId};
        detIdMap.insert(std::make_pair(layerIndex,v));
      }
    }
  }
 
  if (m_usePixelSpacePoints) {
    
    SG::ReadHandle<SpacePointContainer> pixHandle(m_pixelSpacePointsContainerKey, ctx);
 
    if(!pixHandle.isValid()) {
      ATH_MSG_WARNING("Invalid Pixel Spacepoints handle: "<<pixHandle);
      return seedStats;
    }
    
    pixelSpacePointsContainer = pixHandle.ptr();
    
    std::vector<IdentifierHash> listOfPixIds;
    
    m_regsel_pix->lookup(ctx)->HashIDList( internalRoI, listOfPixIds );
 
    const std::vector<short>* h2l = m_layerNumberTool->pixelLayers();
 
    for(const auto& hashId : listOfPixIds) {
      
      short layerIndex = h2l->at(static_cast<int>(hashId));
 
      auto it = detIdMap.find(layerIndex);
      if(it != detIdMap.end()) (*it).second.push_back(hashId);
      else {
        std::vector<IdentifierHash> v = {hashId};
        detIdMap.insert(std::make_pair(layerIndex,v));
      }
    }
  }
 
  if(!m_useGPU) {
 
    std::unique_ptr<GNN_DataStorage> storage = std::make_unique<GNN_DataStorage>(*m_geo, m_mlLUT);
 
    std::vector<const Trk::SpacePoint*> vSP;
 
    vSP.reserve(m_nMaxEdges);
    
    std::vector<std::vector<GNN_Node> > trigSpStorage[2];
    
    trigSpStorage[1].resize(m_layerNumberTool->sctLayers()->size());
 
    trigSpStorage[0].resize(m_layerNumberTool->pixelLayers()->size());
 
    for(const auto& lColl : detIdMap) {
 
      short layerIndex = lColl.first;
 
      int layerKey = m_geo->getTrigFTF_GNN_LayerByIndex(layerIndex)->m_layer.m_subdet;
      
      bool isPixel = layerKey > 20000;
 
      auto pCont = isPixel ? pixelSpacePointsContainer : sctSpacePointsContainer;
 
      int contIdx= isPixel ? 0 : 1;
 
      int nNewNodes = 0;
      
      for(const auto& idx : lColl.second) {
      
        std::vector<GNN_Node>& tmpColl = trigSpStorage[contIdx].at(static_cast<int>(idx));
 
        auto input_coll = pCont->indexFindPtr(idx);
 
        if(input_coll == nullptr) continue;
 
        createGraphNodes(input_coll, tmpColl, vSP, layerIndex, shift_x, shift_y);//TO-DO: if(m_useBeamTilt) SP full transform functor
 
        nNewNodes += (isPixel) ? storage->loadPixelGraphNodes(layerIndex, tmpColl, m_useML) : storage->loadStripGraphNodes(layerIndex, tmpColl);
      }
 
      if(isPixel) nPixels += nNewNodes;
      else nStrips += nNewNodes;      
    }
 
    seedStats.m_nPixelSPs = nPixels;
    seedStats.m_nStripSPs = nStrips;
  
    storage->sortByPhi();
    storage->initializeNodes(m_useML);
    storage->generatePhiIndexing(1.5*m_phiSliceWidth);
 
    std::vector<GNN_Edge> edgeStorage;
 
    std::pair<int, int> graphStats = buildTheGraph(internalRoI, storage, edgeStorage);
 
    ATH_MSG_DEBUG("Created graph with "<<graphStats.first<<" edges and "<<graphStats.second<< " edge links");
 
    seedStats.m_nGraphEdges = graphStats.first;
    seedStats.m_nEdgeLinks  = graphStats.second;
  
    if (graphStats.second == 0) return seedStats;
    
    int maxLevel = runCCA(graphStats.first, edgeStorage);
 
    ATH_MSG_DEBUG("Reached Level "<<maxLevel<<" after GNN iterations");
 
    std::vector<std::pair<float, std::vector<unsigned int> > > vSeedCandidates;
 
    extractSeedsFromTheGraph(maxLevel, graphStats.first, vSP.size(), edgeStorage, vSeedCandidates);
 
    if (vSeedCandidates.empty()) return seedStats;
 
    for(const auto& seed : vSeedCandidates) {
      
      unsigned int lastIdx = output.size();
      output.emplace_back(seed.first);
      
      for(const auto& sp_idx : seed.second) {
    output[lastIdx].addSpacePoint(vSP[sp_idx]);
      }
    }
  
    ATH_MSG_DEBUG("Found "<<output.size()<<" tracklets");  
  }
  else {//GPU-accelerated graph building
        //1. data export
 
        std::vector<const Trk::SpacePoint*> vSP;
        std::vector<short> vL;
 
        vSP.reserve(TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS);
        vL.reserve(TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS);
 
        std::unique_ptr<TrigAccel::DATA_EXPORT_BUFFER> dataBuffer = std::unique_ptr<TrigAccel::DATA_EXPORT_BUFFER>(new TrigAccel::DATA_EXPORT_BUFFER(5000));
        
        size_t dataTypeSize = sizeof(TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA);
        const size_t bufferOffset = 256;
        size_t totalSize = bufferOffset+dataTypeSize;//make room for the header
        if(!dataBuffer->fit(totalSize)) dataBuffer->reallocate(totalSize);
 
        TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA* pJobData = reinterpret_cast<TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA*>(dataBuffer->m_buffer + bufferOffset);
 
        unsigned int spIdx = 0;
        int sp_offset = 0;
        int nLayers = 0;
        int MaxEtaBin = 0;
        int nEtaBins  = 0;
        
        for(const auto& lColl : detIdMap) {
 
            short layerIndex = lColl.first;
            
            const TrigFTF_GNN_Layer* pL = m_geo->getTrigFTF_GNN_LayerByIndex(layerIndex);
 
            int layerKey = pL->m_layer.m_subdet;
            
            bool isPixel = layerKey > 20000;
            bool isBarrel = (pL->m_layer.m_type == 0);
            
            auto pCont = isPixel ? pixelSpacePointsContainer : sctSpacePointsContainer;
            
            pJobData->m_layerIdx[nLayers]        = layerIndex;
 
            pJobData->m_layerInfo[4*nLayers    ]   = spIdx;//layerInfo.x
            pJobData->m_layerInfo[4*nLayers + 2]   = pL->num_bins();//layerInfo.z
            pJobData->m_layerInfo[4*nLayers + 3]   = pL->m_bins[0];//layerInfo.w
            
            pJobData->m_layerGeo[2*nLayers    ]    = pL->m_minEta;//layerGeo.x
            pJobData->m_layerGeo[2*nLayers + 1]    = pL->m_etaBin;//layerGeo.y
            
            nEtaBins += pL->m_bins.size();
            
            for(auto b : pL->m_bins) {
                if(b > MaxEtaBin) MaxEtaBin = b;
            }
 
            for(const auto& idx : lColl.second) {
     
                auto input_coll = pCont->indexFindPtr(idx);
 
                if(input_coll == nullptr) continue;
 
                for(const auto sp : *input_coll) {
 
                    float cw = -1.0;
                    
                    const InDet::PixelCluster* pCL = dynamic_cast<const InDet::PixelCluster*>(sp->clusterList().first);
                    if(pCL != nullptr) {
                        cw = pCL->width().widthPhiRZ().y();
                        if(!isBarrel && m_useML) {
                            if(cw > 0.2) continue;
                            cw = -1.0;//set it to -1 so that it can be skipped later in the ML code on GPU
                        }
                    }
                    
                    vSP.emplace_back(sp);
                    vL.emplace_back(layerIndex);
        
                    const auto& p = sp->globalPosition();
 
                    float params[4] = {(float)(p.x() - shift_x), float(p.y() - shift_y), (float)(p.z()), cw};
 
                    memcpy(&pJobData->m_params[sp_offset], &params[0], sizeof(params));
                    
                    sp_offset += 4;
                    spIdx++;
                    if(spIdx >= TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS) break;
                }       
                if(spIdx >= TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS) break;
            }
 
            pJobData->m_layerInfo[4*nLayers + 1] = spIdx;//layerInfo.y
 
            if (isPixel) nPixels += spIdx - pJobData->m_layerInfo[4*nLayers];
            else nStrips += spIdx - pJobData->m_layerInfo[4*nLayers];
            
            nLayers++;
        }
 
        if(spIdx == 0) return seedStats;
        
        pJobData->m_nSpacepoints = spIdx;
        pJobData->m_nLayers      = nLayers;
        pJobData->m_nEtaBins     = nEtaBins;
        pJobData->m_maxEtaBin    = MaxEtaBin;
        pJobData->m_nMaxEdges    = static_cast<unsigned int>(7*spIdx); 
 
        //load bin pairs
 
        int pairIdx = 0;
        
        for(const auto& bg : m_geo->bin_groups()) {//loop over bin groups
        
            int bin1_idx = bg.first;
                
            for(const auto& bin2_idx : bg.second) {
                pJobData->m_bin_pairs[2*pairIdx  ] = bin1_idx;
                pJobData->m_bin_pairs[2*pairIdx+1] = bin2_idx;
                pairIdx++;
            }
        }
        
        pJobData->m_nBinPairs = pairIdx;
        
        //add algorithm parameters
        
        const float ptCoeff = 0.29997*1.9972/2.0;// ~0.3*B/2 - assuming nominal field of 2*T
 
        float tripletPtMin = 0.8*m_minPt;//correction due to limited pT resolution
 
        float maxCurv = ptCoeff/tripletPtMin;
 
        const float pt_scale = 900/m_minPt;
        
        const float min_deltaPhi_low_dr = 0.002*pt_scale;
        const float dphi_coeff_low_dr   = 4.33e-4*pt_scale;
        const float min_deltaPhi        = 0.015*pt_scale;
        const float dphi_coeff          = 2.2e-4*pt_scale;
        
        const float cut_dphi_max        = m_LRTmode ? 0.07 : 0.012;
        const float cut_dcurv_max       = m_LRTmode ? 0.015 : 0.001;
        const float cut_tau_ratio_max = m_LRTmode ? 0.015f : 0.01;
        const float min_z0              = m_LRTmode ? -600.0 : internalRoI.zedMinus();
        const float max_z0              = m_LRTmode ? 600.0 : internalRoI.zedPlus();
 
        const float maxOuterRadius      = m_LRTmode ? 1050.0 : 550.0;  
        const float minDeltaRadius      = 2.0;
                
        const float cut_zMinU = min_z0 + maxOuterRadius*internalRoI.dzdrMinus();
        const float cut_zMaxU = max_z0 + maxOuterRadius*internalRoI.dzdrPlus();
    
        const float maxKappa            = m_LRTmode ? 1.0*maxCurv : 0.9*maxCurv;
            
        pJobData->m_algo_params[0]  = min_deltaPhi;
        pJobData->m_algo_params[1]  = dphi_coeff;
        pJobData->m_algo_params[2]  = min_deltaPhi_low_dr;
        pJobData->m_algo_params[3]  = dphi_coeff_low_dr;
        pJobData->m_algo_params[4]  = minDeltaRadius;
        pJobData->m_algo_params[5]  = min_z0;
        pJobData->m_algo_params[6]  = max_z0;
        pJobData->m_algo_params[7]  = maxOuterRadius;
        pJobData->m_algo_params[8]  = cut_zMinU;
        pJobData->m_algo_params[9]  = cut_zMaxU;
        pJobData->m_algo_params[10] = maxKappa;
        pJobData->m_algo_params[11] = cut_dphi_max;
        pJobData->m_algo_params[12] = cut_dcurv_max;
        pJobData->m_algo_params[13] = cut_tau_ratio_max;   
        
        int minLevel = 3;//a triplet + 1 confirmation
 
        if(m_LRTmode) {
            minLevel = 2;//a triplet
        }
 
        pJobData->m_minLevel = minLevel;
 
        pJobData->m_useGPUseedExtraction = m_useGPUseedExtraction;          
 
        seedStats.m_nPixelSPs = nPixels;
        seedStats.m_nStripSPs = nStrips;
 
        ATH_MSG_DEBUG("Loaded "<<nPixels<< " Pixel Spacepoints and "<<nStrips<< " Strip SpacePoints");
        
        std::shared_ptr<TrigAccel::OffloadBuffer> pBuff = std::make_shared<TrigAccel::OffloadBuffer>(dataBuffer.get());
    
        std::unique_ptr<TrigAccel::Work> pWork = std::unique_ptr<TrigAccel::Work>(m_accelSvc->createWork(TrigAccel::InDetJobControlCode::RUN_GBTS, pBuff));
    
        if(!pWork) {
            ATH_MSG_WARNING("Failed to create a work item for task "<<TrigAccel::InDetJobControlCode::RUN_GBTS);
            return seedStats;
        }
 
        bool workSuccess = pWork->run();
        if(!workSuccess) {
            ATH_MSG_WARNING("Work item failed to complete");
            return seedStats;
        }    
        
        std::shared_ptr<TrigAccel::OffloadBuffer> pOutput = pWork->getOutput();
        
        TrigAccel::ITk::GRAPH_AND_SEEDS_OUTPUT* pGraphAndSeeds = reinterpret_cast<TrigAccel::ITk::GRAPH_AND_SEEDS_OUTPUT*>(pOutput->m_rawBuffer);
        TrigAccel::ITk::COMPRESSED_GRAPH* pGraph = &pGraphAndSeeds->m_CompressedGraph;
        TrigAccel::ITk::OUTPUT_SEEDS* pSeeds = &pGraphAndSeeds->m_OutputSeeds;
            
        if(m_useGPUseedExtraction) {
            if(pSeeds->m_nSeeds == 0) return seedStats;
            //converting tracklet into GBTS-CPU format
            for(unsigned int seed=0; seed<pSeeds->m_nSeeds; seed++) {
                
                unsigned int lastIdx = output.size();
                output.emplace_back(pSeeds->m_seedsArray[seed].m_Q);
                for(int node=0; node<pSeeds->m_seedsArray[seed].m_size; node++) {
                    output[lastIdx].addSpacePoint(vSP[pSeeds->m_seedsArray[seed].m_nodes[node]]);
                }
            }   
        }
        else {
 
            unsigned int nEdges = pGraph->m_nEdges;
            unsigned int nMaxNei = pGraph->m_nMaxNeighbours;
 
            //populating the edgeStorage
 
            std::vector<GNN_Node> nodes;
 
            nodes.reserve(vSP.size());
 
            for(unsigned int idx = 0;idx < vSP.size(); idx++) {
 
                nodes.emplace_back(vL[idx]);
                
                const auto& pos = vSP[idx]->globalPosition();
                float xs = pos.x() - shift_x;
                float ys = pos.y() - shift_y;
                float zs = pos.z();
                
                nodes[idx].m_x = xs;
                nodes[idx].m_y = ys;
                nodes[idx].m_z = zs;
                nodes[idx].m_r = std::sqrt(xs*xs + ys*ys);
 
                nodes[idx].m_idx = idx;
 
            }
            
            std::vector<GNN_Edge> edgeStorage;
 
            std::pair<int, int> graphStats(0,0);
 
            edgeStorage.resize(nEdges);
 
            unsigned int edgeSize = nMaxNei + 1 + 2;//neigbours, num_neighbours, 2 nodes
 
            for(unsigned int idx=0;idx<nEdges;idx++) {
                unsigned int pos = idx*edgeSize;
                
                int node1Idx = pGraph->m_graphArray[pos + TrigAccel::ITk::node1];
                int node2Idx = pGraph->m_graphArray[pos + TrigAccel::ITk::node2];
                int nNei     = pGraph->m_graphArray[pos + TrigAccel::ITk::nNei];
 
                if(nNei > N_SEG_CONNS) nNei = N_SEG_CONNS;
                
                edgeStorage[idx].m_n1 = &nodes[node1Idx];
                edgeStorage[idx].m_n2 = &nodes[node2Idx];
                edgeStorage[idx].m_level = 1;
                edgeStorage[idx].m_nNei = nNei;
                for(int k=0;k<nNei;k++) {
                    edgeStorage[idx].m_vNei[k] = pGraph->m_graphArray[pos + TrigAccel::ITk::nei_idx_start + k];
                }
            }
            
            graphStats.first = nEdges;
            graphStats.second = pGraph->m_nLinks;
            
            //run the rest of the GBTS workflow
 
            int maxLevel = runCCA(graphStats.first, edgeStorage);
 
            ATH_MSG_DEBUG("Reached Level "<<maxLevel<<" after GNN iterations");
     
            if(maxLevel < minLevel) return seedStats;
        
            std::vector<GNN_Edge*> vSeeds;
 
            vSeeds.reserve(graphStats.first/2);
 
            for(int edgeIndex=0;edgeIndex<graphStats.first;edgeIndex++) {
                GNN_Edge* pS = &(edgeStorage.at(edgeIndex));
 
                if(pS->m_level < minLevel) continue;
                
                vSeeds.push_back(pS);
            }
        
            if(vSeeds.empty()) return seedStats;
     
            std::sort(vSeeds.begin(), vSeeds.end(), GNN_Edge::CompareLevel());
 
            //backtracking
 
            TrigFTF_GNN_TrackingFilter tFilter(m_layerGeometry, edgeStorage);
 
            output.reserve(vSeeds.size());
        
            for(auto pS : vSeeds) {
                
                if(pS->m_level == -1) continue;
                
                TrigFTF_GNN_EdgeState rs(false);
                
                tFilter.followTrack(pS, rs);
      
                if(!rs.m_initialized) {
                    continue;
                }
      
                if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
      
                std::vector<const GNN_Node*> vN;
      
                for(std::vector<GNN_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
        
                    (*sIt)->m_level = -1;//mark as collected
    
                    if(sIt == rs.m_vs.rbegin()) {
                        vN.push_back((*sIt)->m_n1);
                    }
                    vN.push_back((*sIt)->m_n2);
                }
      
                if(vN.size()<3) continue;
      
                unsigned int lastIdx = output.size();
                output.emplace_back(rs.m_J);
      
                for(const auto& n : vN) {
                    output[lastIdx].addSpacePoint(vSP[n->m_idx]);
                }
            }
        }
        ATH_MSG_DEBUG("Found "<<output.size()<<" tracklets");
  }
  return seedStats;  
}

initialize()

StatusCode TrigInDetTrackSeedingTool::initialize ( )

overridevirtual

Reimplemented from SeedingToolBase.

Definition at line 34 of file TrigInDetTrackSeedingTool.cxx.

                                                 {
 
  ATH_CHECK(SeedingToolBase::initialize());
  
  ATH_CHECK(m_regsel_pix.retrieve());
  ATH_CHECK(m_regsel_sct.retrieve());
 
  ATH_CHECK(m_beamSpotKey.initialize());
 
  if(m_useGPU) {//for GPU offloading
    ATH_CHECK(m_accelSvc.retrieve());
    ATH_CHECK(m_accelSvc->isReady());
  }
 
  if (!m_usePixelSpacePoints && !m_useSctSpacePoints) {
    ATH_MSG_FATAL("Both usePixelSpacePoints and useSctSpacePoints set to False. At least one needs to be True");
    return StatusCode::FAILURE;
  }
 
  if (!m_useSctSpacePoints) ATH_MSG_INFO("Only using Pixel spacepoints => Pixel seeds only");
 
  if (!m_usePixelSpacePoints) ATH_MSG_INFO("Only using SCT spacepoints => Strip seeds only");
 
  if (m_usePixelSpacePoints && m_useSctSpacePoints) ATH_MSG_INFO("Using SCT and Pixel spacepoints");
 
  ATH_CHECK(m_pixelSpacePointsContainerKey.initialize(m_usePixelSpacePoints));
 
  ATH_CHECK(m_sctSpacePointsContainerKey.initialize(m_useSctSpacePoints));
  
  ATH_MSG_INFO("TrigInDetTrackSeedingTool initialized with " << m_useGPU);
  
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

runCCA() [1/2]

int SeedingToolBase::runCCA ( int nEdges, std::vector< GNN_Edge > & edgeStorage ) const

protectedinherited

Definition at line 434 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

                                                                                      {
 
  constexpr int maxIter = 15;
 
  int maxLevel = 0;
 
  int iter = 0;
  
  std::vector<TrigFTF_GNN_Edge*> v_old;
  
  for(int edgeIndex=0;edgeIndex<nEdges;edgeIndex++) {
 
    TrigFTF_GNN_Edge* pS = &(edgeStorage[edgeIndex]);
    if(pS->m_nNei == 0) continue;
    
    v_old.push_back(pS);//TO-DO: increment level for segments as they already have at least one neighbour
  }
 
  std::vector<TrigFTF_GNN_Edge*> v_new;
  v_new.reserve(v_old.size());
 
  for(;iter<maxIter;iter++) {
 
    //generate proposals
    v_new.clear();
    
    for(auto pS : v_old) {
      
      int next_level = pS->m_level;
          
      for(int nIdx=0;nIdx<pS->m_nNei;nIdx++) {
    
        unsigned int nextEdgeIdx = pS->m_vNei[nIdx];
            
        TrigFTF_GNN_Edge* pN = &(edgeStorage[nextEdgeIdx]);
            
        if(pS->m_level == pN->m_level) {
          next_level = pS->m_level + 1;
          v_new.push_back(pS);
          break;
        }
      }
      
      pS->m_next = next_level;//proposal
    }
  
    //update
 
    int nChanges = 0;
      
    for(auto pS : v_new) {
      if(pS->m_next != pS->m_level) {
        nChanges++;
        pS->m_level = pS->m_next;
        if(maxLevel < pS->m_level) maxLevel = pS->m_level;
      }
    }
 
    if(nChanges == 0) break;
 
 
    v_old.swap(v_new);
    v_new.clear();
  }
 
  return maxLevel;  
}

runCCA() [2/2]

int SeedingToolBase::runCCA ( int nEdges, std::vector< GNNR3_Edge > & edgeStorage ) const

protectedinherited

Definition at line 297 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.cxx.

                                                                                        {
 
  const int maxIter = 15;
 
  int maxLevel = 0;
 
  int iter = 0;
  
  std::vector<TrigFTF_GNNR3_Edge*> v_old;
  
  for(int edgeIndex=0;edgeIndex<nEdges;edgeIndex++) {
 
    TrigFTF_GNNR3_Edge* pS = &(edgeStorage[edgeIndex]);
    if(pS->m_nNei == 0) continue;
    
    v_old.push_back(pS);//TO-DO: increment level for segments as they already have at least one neighbour
  }
 
  for(;iter<maxIter;iter++) {
 
    //generate proposals
    std::vector<TrigFTF_GNNR3_Edge*> v_new;
    v_new.clear();
    v_new.reserve(v_old.size());
    
    for(auto pS : v_old) {
      
      int next_level = pS->m_level;
          
      for(int nIdx=0;nIdx<pS->m_nNei;nIdx++) {
    
        unsigned int nextEdgeIdx = pS->m_vNei[nIdx];
            
        TrigFTF_GNNR3_Edge* pN = &(edgeStorage[nextEdgeIdx]);
            
        if(pS->m_level == pN->m_level) {
          next_level = pS->m_level + 1;
          v_new.push_back(pS);
          break;
        }
      }
      
      pS->m_next = next_level;//proposal
    }
  
    //update
 
    int nChanges = 0;
      
    for(auto pS : v_new) {
      if(pS->m_next != pS->m_level) {
        nChanges++;
        pS->m_level = pS->m_next;
        if(maxLevel < pS->m_level) maxLevel = pS->m_level;
      }
    }
 
    if(nChanges == 0) break;
 
 
    v_old = std::move(v_new);
    v_new.clear();
  }
 
  return maxLevel;  
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_accelSvc

ServiceHandle<ITrigInDetAccelerationSvc> TrigInDetTrackSeedingTool::m_accelSvc {this, "TrigAccelerationSvc", ""}

protected

Definition at line 72 of file TrigInDetTrackSeedingTool.h.

{this, "TrigAccelerationSvc", ""};

m_atlasId

const AtlasDetectorID * SeedingToolBase::m_atlasId = nullptr

protectedinherited

Definition at line 54 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> TrigInDetTrackSeedingTool::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }

protected

Definition at line 55 of file TrigInDetTrackSeedingTool.h.

{ this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };

m_connectionFile

StringProperty SeedingToolBase::m_connectionFile {this, "ConnectionFileName", "binTables_ITK_RUN4.txt"}

protectedinherited

Definition at line 71 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "ConnectionFileName", "binTables_ITK_RUN4.txt"};

m_connector [1/2]

std::unique_ptr<GNN_FasTrackConnector> SeedingToolBase::m_connector = nullptr

protectedinherited

Definition at line 81 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

m_connector [2/2]

std::unique_ptr<GNNR3_FasTrackConnector> SeedingToolBase::m_connector = nullptr

protectedinherited

Definition at line 67 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doubletFilterRZ

BooleanProperty SeedingToolBase::m_doubletFilterRZ {this, "Doublet_FilterRZ", true}

protectedinherited

Definition at line 64 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "Doublet_FilterRZ", true};

m_etaBinOverride

FloatProperty SeedingToolBase::m_etaBinOverride {this, "etaBin", 0.0f, "specify non-zero to override eta bin width from connection file (default 0.2 in createLinkingScheme.py)"}

protectedinherited

Definition at line 68 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "etaBin", 0.0f, "specify non-zero to override eta bin width from connection file (default 0.2 in createLinkingScheme.py)"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_filter_phi

BooleanProperty SeedingToolBase::m_filter_phi {this, "DoPhiFiltering", true}

protectedinherited

Definition at line 58 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "DoPhiFiltering", true};

m_geo [1/2]

std::unique_ptr<const TrigFTF_GNN_Geometry> SeedingToolBase::m_geo = nullptr

protectedinherited

Definition at line 83 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

m_geo [2/2]

std::unique_ptr<const TrigFTF_GNNR3_Geometry> SeedingToolBase::m_geo = nullptr

protectedinherited

Definition at line 69 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.h.

m_layerGeometry

std::vector< TrigInDetSiLayer > SeedingToolBase::m_layerGeometry

protectedinherited

Definition at line 82 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

m_layerNumberTool

ToolHandle< ITrigL2LayerNumberTool > SeedingToolBase::m_layerNumberTool {this, "layerNumberTool", "TrigL2LayerNumberToolITk"}

protectedinherited

Definition at line 52 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "layerNumberTool", "TrigL2LayerNumberToolITk"};

m_LRTmode

BooleanProperty SeedingToolBase::m_LRTmode {this, "LRTMode",false}

protectedinherited

Definition at line 60 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "LRTMode",false};

m_lutFile

StringProperty SeedingToolBase::m_lutFile {this, "MLpredictorLutFileName", "gbts_ml_pixel_barrel_loose.lut"}

protectedinherited

Definition at line 72 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "MLpredictorLutFileName", "gbts_ml_pixel_barrel_loose.lut"};

m_matchBeforeCreate

BooleanProperty SeedingToolBase::m_matchBeforeCreate {this, "MatchBeforeCreate", true}

protectedinherited

Definition at line 66 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "MatchBeforeCreate", true};

m_minPt

FloatProperty SeedingToolBase::m_minPt {this, "pTmin", 1000.0}

protectedinherited

Definition at line 67 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "pTmin", 1000.0};

m_mlLUT

std::vector<std::array<float, 5> > SeedingToolBase::m_mlLUT

protectedinherited

Definition at line 84 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

m_nBufferEdges

IntegerProperty SeedingToolBase::m_nBufferEdges {this, "BufferEdges", 200000}

protectedinherited

Definition at line 70 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "BufferEdges", 200000};

m_nMaxEdges

IntegerProperty SeedingToolBase::m_nMaxEdges {this, "MaxGraphEdges", 2000000}

protectedinherited

Definition at line 69 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "MaxGraphEdges", 2000000};

m_nMaxPhiSlice

UnsignedIntegerProperty SeedingToolBase::m_nMaxPhiSlice {this, "nMaxPhiSlice", 53}

protectedinherited

Definition at line 63 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "nMaxPhiSlice", 53};

m_phiSliceWidth

float SeedingToolBase::m_phiSliceWidth = 0.

protectedinherited

Definition at line 79 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

m_pixelId

const PixelID * SeedingToolBase::m_pixelId = nullptr

protectedinherited

Definition at line 56 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

m_pixelSpacePointsContainerKey

SG::ReadHandleKey<SpacePointContainer> TrigInDetTrackSeedingTool::m_pixelSpacePointsContainerKey {this, "PixelSP_ContainerName", "ITkPixelTrigSpacePoints"}

protected

Definition at line 62 of file TrigInDetTrackSeedingTool.h.

{this, "PixelSP_ContainerName", "ITkPixelTrigSpacePoints"};

m_regsel_pix

ToolHandle<IRegSelTool> TrigInDetTrackSeedingTool::m_regsel_pix { this, "RegSelTool_Pixel", "RegSelTool/RegSelTool_Pixel" }

protected

region selector tools

Definition at line 66 of file TrigInDetTrackSeedingTool.h.

{ this, "RegSelTool_Pixel",  "RegSelTool/RegSelTool_Pixel" };

m_regsel_sct

ToolHandle<IRegSelTool> TrigInDetTrackSeedingTool::m_regsel_sct { this, "RegSelTool_SCT", "RegSelTool/RegSelTool_SCT" }

protected

Definition at line 67 of file TrigInDetTrackSeedingTool.h.

{ this, "RegSelTool_SCT",    "RegSelTool/RegSelTool_SCT"   };

m_sctId

const SCT_ID * SeedingToolBase::m_sctId = nullptr

protectedinherited

Definition at line 55 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

m_sctSpacePointsContainerKey

SG::ReadHandleKey<SpacePointContainer> TrigInDetTrackSeedingTool::m_sctSpacePointsContainerKey {this, "SCT_SP_ContainerName", "ITkStripTrigSpacePoints"}

protected

Definition at line 61 of file TrigInDetTrackSeedingTool.h.

{this, "SCT_SP_ContainerName", "ITkStripTrigSpacePoints"};

m_tau_ratio_cut

FloatProperty SeedingToolBase::m_tau_ratio_cut {this, "tau_ratio_cut", 0.007}

protectedinherited

Definition at line 77 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "tau_ratio_cut", 0.007};

m_useBeamTilt

BooleanProperty SeedingToolBase::m_useBeamTilt {this, "UseBeamTilt", false}

protectedinherited

Definition at line 59 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "UseBeamTilt", false};

m_useEtaBinning

BooleanProperty SeedingToolBase::m_useEtaBinning {this, "UseEtaBinning", true}

protectedinherited

Definition at line 65 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "UseEtaBinning", true};

m_useGPU

BooleanProperty TrigInDetTrackSeedingTool::m_useGPU {this, "UseGPU", false}

protected

Definition at line 71 of file TrigInDetTrackSeedingTool.h.

{this, "UseGPU", false};

m_useGPUseedExtraction

BooleanProperty SeedingToolBase::m_useGPUseedExtraction {this, "UseGPUseedExtraction", true}

protectedinherited

Definition at line 74 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "UseGPUseedExtraction", true};

m_useML

BooleanProperty SeedingToolBase::m_useML {this, "useML", true}

protectedinherited

Definition at line 61 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "useML", true};

m_useOldTunings

BooleanProperty SeedingToolBase::m_useOldTunings {this, "UseOldTunings", false}

protectedinherited

Definition at line 75 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

{this, "UseOldTunings", false};

m_usePixelSpacePoints

BooleanProperty TrigInDetTrackSeedingTool::m_usePixelSpacePoints {this, "UsePixelSpacePoints", true}

protected

Definition at line 57 of file TrigInDetTrackSeedingTool.h.

{this,  "UsePixelSpacePoints", true};

m_useSctSpacePoints

BooleanProperty TrigInDetTrackSeedingTool::m_useSctSpacePoints {this, "UseSctSpacePoints", false}

protected

Definition at line 58 of file TrigInDetTrackSeedingTool.h.

{this, "UseSctSpacePoints", false};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• TrigInDetTrackSeedingTool.h
• TrigInDetTrackSeedingTool.cxx