#include <GbtsSeedingTool.h>

Inheritance diagram for ActsTrk::GbtsSeedingTool:

Collaboration diagram for ActsTrk::GbtsSeedingTool:

Public Types
using	seed_type = ActsSeed< xAOD::SpacePoint >

Public Member Functions
	GbtsSeedingTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual	~GbtsSeedingTool ()=default

virtual StatusCode	initialize () override

virtual StatusCode	createSeeds (const EventContext &ctx, const Acts::SpacePointContainer< ActsTrk::SpacePointCollector, Acts::detail::RefHolder > &spContainer, const Acts::Vector3 &beamSpotPos, const Acts::Vector3 &bField, ActsTrk::SeedContainer &seedContainer) const override

std::vector< Acts::Experimental::TrigInDetSiLayer >	LayerNumbering () const

std::pair< int, int >	getCombinedID (const int eta_mod, const short barrel_ec, const int lay_id) const

Private Member Functions
StatusCode	prepareConfiguration ()

const Acts::Logger &	logger () const
	Private access to the logger. More...

Private Attributes
Acts::Experimental::SeedFinderGbtsConfig< xAOD::SpacePoint >	m_finderCfg

std::unique_ptr< Acts::Experimental::GbtsGeometry< xAOD::SpacePoint > >	m_gbtsGeo = nullptr

const PixelID *	m_pixelId = nullptr

const InDetDD::PixelDetectorManager *	m_pixelManager = nullptr

Gaudi::Property< float >	m_minPt

Gaudi::Property< float >	m_sigmaScattering

Gaudi::Property< float >	m_highland {this, "highland",0, "need to check "}

Gaudi::Property< float >	m_maxScatteringAngle2 {this, "maxScatteringAngle2",0, "need to check "}

Gaudi::Property< float >	m_helixCutTolerance {this, "helixCutTolerance",1, "Parameter which can loosen the tolerance of the track seed to form a helix. This is useful for e.g. misaligned seeding."}

Gaudi::Property< float >	m_phiSliceWidth {this, "phiSliceWidth",0, "initialised in loadSpacePoints function"}

Gaudi::Property< float >	m_nMaxPhiSlice {this, "nMaxPhiSlice",53, "used to calculate phi slices"}

Gaudi::Property< bool >	m_useClusterWidth {this, "useClusterWidth",false, "bool for use of cluster width in loadSpacePoints function"}

Gaudi::Property< std::string >	m_ConnectorInputFile {this, "ConnectorInputFile","binTables_ITK_RUN4.txt", "input file for making connector object"}

Gaudi::Property< bool >	m_useEtaBinning {this, "useEtaBinning",true, "bool to use eta binning from geometry structure"}

Gaudi::Property< bool >	m_doubletFilterRZ {this, "doubletFilterRZ",true, "bool applies new Z cuts on doublets"}

Gaudi::Property< float >	m_minDeltaRadius {this, "minDeltaRadius",2.0, " min dr for doublet"}

Gaudi::Property< float >	m_tripletD0Max {this, "tripletD0Max",4.0, " D0 cut for triplets"}

Gaudi::Property< unsigned int >	m_maxTripletBufferLength {this, "maxTripletBufferLength",3, " maximum number of space points per triplet"}

Gaudi::Property< int >	m_MaxEdges {this, "MaxEdges",2000000, " max number of Gbts edges/doublets"}

Gaudi::Property< float >	m_cut_dphi_max {this, "cut_dphi_max",0.012, " phi cut for triplets"}

Gaudi::Property< float >	m_cut_dcurv_max {this, "cut_dcurv_max",0.001, " curv cut for triplets"}

Gaudi::Property< float >	m_cut_tau_ratio_max {this, "cut_tau_ratio_max",0.007, "tau cut for doublets and triplets"}

Gaudi::Property< float >	m_maxOuterRadius {this, "maxOuterRadius",550.0, "used to calculate Z cut on doublets"}

Gaudi::Property< float >	m_PtMin {this, "PtMin",1000.0, "pt limit used to caluclate triplet pT"}

Gaudi::Property< float >	m_tripletPtMinFrac {this, "tripletPtMinFrac",0.3, "used to caluclate triplet pt"}

Gaudi::Property< float >	m_tripletPtMin {this, "tripletPtMin",m_PtMin * m_tripletPtMinFrac, "Limit on triplet pt"}

Gaudi::Property< double >	m_ptCoeff {this, "ptCoeff", 0.29997 * 1.9972 / 2.0, "~0.3B/2 - assumes nominal field of 2T"}

SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_pixelDetEleCollKey {this, "PixelDetectorElements", "ITkPixelDetectorElementCollection", "Key of input SiDetectorElementCollection for Pixel"}

std::unique_ptr< const Acts::Logger >	m_logger {nullptr}
	logging instance More...

Detailed Description

Definition at line 48 of file GbtsSeedingTool.h.

Member Typedef Documentation

◆ seed_type

using ActsTrk::GbtsSeedingTool::seed_type = ActsSeed< xAOD::SpacePoint >

Definition at line 52 of file GbtsSeedingTool.h.

Constructor & Destructor Documentation

◆ GbtsSeedingTool()

ActsTrk::GbtsSeedingTool::GbtsSeedingTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 15 of file GbtsSeedingTool.cxx.

18 : base_class(type, name, parent)

19 {}

◆ ~GbtsSeedingTool()

virtual ActsTrk::GbtsSeedingTool::~GbtsSeedingTool ( )

virtualdefault

Member Function Documentation

◆ createSeeds()

ATH_FLATTEN StatusCode ActsTrk::GbtsSeedingTool::createSeeds	(	const EventContext &	ctx,
		const Acts::SpacePointContainer< ActsTrk::SpacePointCollector, Acts::detail::RefHolder > &	spContainer,
		const Acts::Vector3 &	beamSpotPos,
		const Acts::Vector3 &	bField,
		ActsTrk::SeedContainer &	seedContainer
	)		const

overridevirtual

Definition at line 54 of file GbtsSeedingTool.cxx.

   {
     // Seed Finder Options
     Acts::SeedFinderOptions finderOpts;
     finderOpts.beamPos = Acts::Vector2(beamSpotPos[Amg::x],
                                        beamSpotPos[Amg::y]);
     finderOpts.bFieldInZ = bField[2];
     finderOpts = finderOpts.toInternalUnits().calculateDerivedQuantities(m_finderCfg);
     
     // // // Compute seeds
     SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle = SG::makeHandle(m_pixelDetEleCollKey, ctx);
     ATH_CHECK(pixelDetEleHandle.isValid()) ;
     const InDetDD::SiDetectorElementCollection* pixelElements = pixelDetEleHandle.cptr();
   
  
     std::vector<Acts::Experimental::GbtsSP<xAOD::SpacePoint>> GbtsSpacePoints;
     GbtsSpacePoints.reserve(
         spContainer.size()); 
  
     // for loop filling space
     for (const auto& spacePoint : spContainer) { //xaod space points
         // loop over space points, get necessary info from athena: 
       const std::vector<xAOD::DetectorIDHashType>& elementlist = spacePoint.externalSpacePoint().elementIdList() ;
  
         for (const xAOD::DetectorIDHashType element : elementlist) { 
  
           const InDetDD::SiDetectorElement* pixelElement = pixelElements->getDetectorElement(element);
  
           Identifier Identifier = pixelElement->identify() ; 
  
           int eta_mod = m_pixelId->eta_module(Identifier); 
           short barrel_ec = m_pixelId->barrel_ec(Identifier); 
           int lay_id = m_pixelId->layer_disk(Identifier);
           int combined_id = getCombinedID(eta_mod,barrel_ec,lay_id).first ; 
           int Gbts_id = getCombinedID(eta_mod,barrel_ec,lay_id).second ; 
         
           // fill Gbts vector with current sapce point and ID
           float ClusterWidth = 0; //for now trying to fill this  
         
           // fill Gbts vector with current sapce point and ID
           GbtsSpacePoints.emplace_back(&spacePoint.externalSpacePoint(), Gbts_id, combined_id, ClusterWidth); 
           //constructor takes (const space_point_t *sp, 
  
         }
       
     }
  
     ATH_MSG_VERBOSE("Space points successfully assigned Gbts ID");
  
     Acts::Experimental::SeedFinderGbts<xAOD::SpacePoint> finder = Acts::Experimental::SeedFinderGbts<xAOD::SpacePoint>(m_finderCfg,*m_gbtsGeo);  
  
     finder.loadSpacePoints(GbtsSpacePoints);
     //temporary solution until trigger ROIs implemented 
     Acts::Experimental::RoiDescriptor internalRoi(0, -4.5, 4.5, 0, -std::numbers::pi, std::numbers::pi, 0, -150.0,150.0); //(eta,etaMinus,etaPlus,phi,phiMinus,Phiplus,z,zMinus,zPlus)
  
     std::vector<Acts::Seed<xAOD::SpacePoint, 3ul>> groupSeeds = finder.createSeeds(internalRoi, *m_gbtsGeo);
  
     // Store seeds
  
     seedContainer.reserve(groupSeeds.size());
     for( Acts::Seed<xAOD::SpacePoint, 3ul>& seed: groupSeeds) {
       //turn interim into group seeds 
  
       const auto& spacepoints = seed.sp() ; 
       assert(spacepoints.size()==3) ;  
       const xAOD::SpacePoint* sp1 = spacepoints[0] ; 
       const xAOD::SpacePoint* sp2 = spacepoints[1] ; 
       const xAOD::SpacePoint* sp3 = spacepoints[2] ; 
  
       std::unique_ptr<seed_type> to_add = std::make_unique<seed_type>(*sp1, *sp2, *sp3);
       to_add->setVertexZ(seed.z());
       to_add->setQuality(seed.seedQuality());
       seedContainer.push_back(std::move(to_add));  
  
     }
  
     return StatusCode::SUCCESS;
   }

◆ getCombinedID()

std::pair< int, int > ActsTrk::GbtsSeedingTool::getCombinedID	(	const int	eta_mod,
		const short	barrel_ec,
		const int	lay_id
	)		const

Definition at line 235 of file GbtsSeedingTool.cxx.

                                                                                                                   { 
     int vol_id = -1 ;         
     if(barrel_ec== 0) vol_id = 8;
     if(barrel_ec==-2) vol_id = 7;
     if(barrel_ec== 2) vol_id = 9;
         
     int new_vol=0, new_lay=0;
     if(vol_id == 7 || vol_id == 9) {
       new_vol = 10*vol_id + lay_id;
       new_lay = eta_mod;
     }
     else if(vol_id == 8) {
       new_lay = 0;
       new_vol = 10*vol_id + lay_id;
     }
     //make into the form needed for acts 
     int Gbts_id = new_vol ; 
     int combined_id = new_vol * 1000 + new_lay;
  
     return std::make_pair(combined_id,Gbts_id) ; 
   }

◆ initialize()

StatusCode ActsTrk::GbtsSeedingTool::initialize ( )

overridevirtual

Definition at line 21 of file GbtsSeedingTool.cxx.

                                          {
     ATH_MSG_DEBUG("Initializing " << name() << "...");
  
     ATH_CHECK( detStore()->retrieve(m_pixelId, "PixelID") );
     ATH_CHECK( detStore()->retrieve(m_pixelManager, "ITkPixel") );    
  
     ATH_CHECK( m_pixelDetEleCollKey.initialize() );
  
     ATH_MSG_DEBUG("Properties Summary:");
     ATH_MSG_DEBUG(" *  Used by SeedFinderGbtsConfig");
  
     // Make the logger And Propagate to ACTS routines
     m_logger = makeActsAthenaLogger(this, "Acts");
  
     ATH_CHECK( prepareConfiguration() );
  
      // input trig vector
     m_finderCfg.m_layerGeometry = LayerNumbering();
  
     std::ifstream input_ifstream(
          m_finderCfg.ConnectorInputFile.c_str(), std::ifstream::in); //change to connector input file 
     // connector
     std::unique_ptr<Acts::Experimental::GbtsConnector> inputConnector =  
         std::make_unique<Acts::Experimental::GbtsConnector>(input_ifstream);
         
     m_gbtsGeo = std::make_unique<Acts::Experimental::GbtsGeometry<xAOD::SpacePoint>>( 
       m_finderCfg.m_layerGeometry, inputConnector);
  
     return StatusCode::SUCCESS;
   }

◆ LayerNumbering()

std::vector< Acts::Experimental::TrigInDetSiLayer > ActsTrk::GbtsSeedingTool::LayerNumbering ( ) const

Definition at line 139 of file GbtsSeedingTool.cxx.

                                         {
     std::vector<std::size_t> count_vector;
     std::vector<Acts::Experimental::TrigInDetSiLayer> input_vector;
  
     for(int hash = 0; hash<static_cast<int>(m_pixelId->wafer_hash_max()); hash++) {
       const Identifier offlineId = m_pixelId->wafer_id(hash); 
       const int eta_mod = m_pixelId->eta_module(offlineId); 
       const short barrel_ec = m_pixelId->barrel_ec(offlineId); 
       const int lay_id = m_pixelId->layer_disk(offlineId);     
  
       const int combined_id = getCombinedID(eta_mod,barrel_ec,lay_id).first ; 
  
       float rc = 0.0;
       float minBound = std::numeric_limits<float>::max(); 
       float maxBound = -std::numeric_limits<float>::max(); 
  
       //want center and bounds! 
       const InDetDD::SiDetectorElement *p = m_pixelManager->getDetectorElement(offlineId);
       const Amg::Vector3D C = p->center() ;
  
       if(barrel_ec == 0) {
         rc += std::sqrt(C(0)*C(0)+C(1)*C(1));
         if(p->zMin() < minBound) minBound = p->zMin();
         if(p->zMax() > maxBound) maxBound = p->zMax();
       }
       else {
         rc += C(2);
         if(p->rMin() < minBound) minBound = p->rMin();
         if(p->rMax() > maxBound) maxBound = p->rMax();  
       }
  
     
       auto current_index =
           find_if(input_vector.begin(), input_vector.end(),
                   [combined_id](auto n) { return n.m_subdet == combined_id; });
       if (current_index != input_vector.end()) {  // not end so does exist
         std::size_t index = std::distance(input_vector.begin(), current_index);
         input_vector[index].m_refCoord += rc;
         input_vector[index].m_minBound += minBound;
         input_vector[index].m_maxBound += maxBound;
         count_vector[index] += 1;  // increase count at the index
  
       } else {  // end so doesn't exists
         // make new if one with Gbts ID doesn't exist:
         Acts::Experimental::TrigInDetSiLayer new_Gbts_ID(combined_id, barrel_ec, rc, minBound,
                                           maxBound);
         input_vector.push_back(new_Gbts_ID);
         count_vector.push_back(
             1);  // so the element exists and not divinding by 0
       }
  
     }
     for (std::size_t i = 0; i < input_vector.size(); ++i) {
       assert(count_vector[i] != 0);
       input_vector[i].m_refCoord = input_vector[i].m_refCoord / count_vector[i];
     }
  
     return input_vector;
   }

◆ logger()

const Acts::Logger& ActsTrk::GbtsSeedingTool::logger ( ) const

inlineprivate

Private access to the logger.

Definition at line 128 of file GbtsSeedingTool.h.

128 { return *m_logger; }

◆ prepareConfiguration()

StatusCode ActsTrk::GbtsSeedingTool::prepareConfiguration ( )

private

Definition at line 201 of file GbtsSeedingTool.cxx.

   {
     // Configuration Acts::SeedFinderGbts
  
     m_finderCfg.minPt = m_minPt;
     m_finderCfg.sigmaScattering = m_sigmaScattering;
     m_finderCfg.highland = m_highland;
     m_finderCfg.maxScatteringAngle2 = m_maxScatteringAngle2;
     m_finderCfg.helixCutTolerance = m_helixCutTolerance ;
     m_finderCfg.m_phiSliceWidth = m_phiSliceWidth ;
     m_finderCfg.m_nMaxPhiSlice = m_nMaxPhiSlice;
     m_finderCfg.m_useClusterWidth = m_useClusterWidth;
     m_finderCfg.ConnectorInputFile = m_ConnectorInputFile;
     m_finderCfg.m_useEtaBinning = m_useEtaBinning;
     m_finderCfg.m_doubletFilterRZ = m_doubletFilterRZ ;
     m_finderCfg.m_minDeltaRadius = m_minDeltaRadius;
     m_finderCfg.m_tripletD0Max = m_tripletD0Max;
     m_finderCfg.m_maxTripletBufferLength = m_maxTripletBufferLength;
     m_finderCfg.MaxEdges = m_MaxEdges;
     m_finderCfg.cut_dphi_max = m_cut_dphi_max;
     m_finderCfg.cut_dcurv_max = m_cut_dcurv_max;
     m_finderCfg.cut_tau_ratio_max = m_cut_tau_ratio_max;
     m_finderCfg.maxOuterRadius = m_maxOuterRadius;
     m_finderCfg.m_PtMin = m_PtMin;
     m_finderCfg.m_tripletPtMinFrac = m_tripletPtMinFrac;
     m_finderCfg.m_tripletPtMin = m_tripletPtMin;
     m_finderCfg.ptCoeff = m_ptCoeff;
  
     m_finderCfg = m_finderCfg.toInternalUnits();
  
  
     return StatusCode::SUCCESS;
   }

Member Data Documentation

◆ m_ConnectorInputFile

Gaudi::Property<std::string> ActsTrk::GbtsSeedingTool::m_ConnectorInputFile {this, "ConnectorInputFile","binTables_ITK_RUN4.txt", "input file for making connector object"}

private

Definition at line 107 of file GbtsSeedingTool.h.

◆ m_cut_dcurv_max

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_cut_dcurv_max {this, "cut_dcurv_max",0.001, " curv cut for triplets"}

private

Definition at line 117 of file GbtsSeedingTool.h.

◆ m_cut_dphi_max

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_cut_dphi_max {this, "cut_dphi_max",0.012, " phi cut for triplets"}

private

Definition at line 116 of file GbtsSeedingTool.h.

◆ m_cut_tau_ratio_max

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_cut_tau_ratio_max {this, "cut_tau_ratio_max",0.007, "tau cut for doublets and triplets"}

private

Definition at line 118 of file GbtsSeedingTool.h.

◆ m_doubletFilterRZ

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_doubletFilterRZ {this, "doubletFilterRZ",true, "bool applies new Z cuts on doublets"}

private

Definition at line 111 of file GbtsSeedingTool.h.

◆ m_finderCfg

Acts::Experimental::SeedFinderGbtsConfig<xAOD::SpacePoint> ActsTrk::GbtsSeedingTool::m_finderCfg

private

Definition at line 82 of file GbtsSeedingTool.h.

◆ m_gbtsGeo

std::unique_ptr<Acts::Experimental::GbtsGeometry<xAOD::SpacePoint> > ActsTrk::GbtsSeedingTool::m_gbtsGeo = nullptr

private

Definition at line 84 of file GbtsSeedingTool.h.

◆ m_helixCutTolerance

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_helixCutTolerance {this, "helixCutTolerance",1, "Parameter which can loosen the tolerance of the track seed to form a helix. This is useful for e.g. misaligned seeding."}

private

Definition at line 101 of file GbtsSeedingTool.h.

◆ m_highland

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_highland {this, "highland",0, "need to check "}

private

Definition at line 98 of file GbtsSeedingTool.h.

◆ m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::GbtsSeedingTool::m_logger {nullptr}

private

logging instance

Definition at line 130 of file GbtsSeedingTool.h.

◆ m_MaxEdges

Gaudi::Property<int> ActsTrk::GbtsSeedingTool::m_MaxEdges {this, "MaxEdges",2000000, " max number of Gbts edges/doublets"}

private

Definition at line 115 of file GbtsSeedingTool.h.

◆ m_maxOuterRadius

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_maxOuterRadius {this, "maxOuterRadius",550.0, "used to calculate Z cut on doublets"}

private

Definition at line 119 of file GbtsSeedingTool.h.

◆ m_maxScatteringAngle2

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_maxScatteringAngle2 {this, "maxScatteringAngle2",0, "need to check "}

private

Definition at line 99 of file GbtsSeedingTool.h.

◆ m_maxTripletBufferLength

Gaudi::Property<unsigned int> ActsTrk::GbtsSeedingTool::m_maxTripletBufferLength {this, "maxTripletBufferLength",3, " maximum number of space points per triplet"}

private

Definition at line 114 of file GbtsSeedingTool.h.

◆ m_minDeltaRadius

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_minDeltaRadius {this, "minDeltaRadius",2.0, " min dr for doublet"}

private

Definition at line 112 of file GbtsSeedingTool.h.

◆ m_minPt

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_minPt

private

Initial value:

{this, "minPt", 900. * Acts::UnitConstants::MeV,

"Lower cutoff for seeds"}

Definition at line 90 of file GbtsSeedingTool.h.

◆ m_nMaxPhiSlice

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_nMaxPhiSlice {this, "nMaxPhiSlice",53, "used to calculate phi slices"}

private

Definition at line 105 of file GbtsSeedingTool.h.

◆ m_phiSliceWidth

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_phiSliceWidth {this, "phiSliceWidth",0, "initialised in loadSpacePoints function"}

private

Definition at line 104 of file GbtsSeedingTool.h.

◆ m_pixelDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> ActsTrk::GbtsSeedingTool::m_pixelDetEleCollKey {this, "PixelDetectorElements", "ITkPixelDetectorElementCollection", "Key of input SiDetectorElementCollection for Pixel"}

private

Definition at line 125 of file GbtsSeedingTool.h.

◆ m_pixelId

const PixelID* ActsTrk::GbtsSeedingTool::m_pixelId = nullptr

private

Definition at line 86 of file GbtsSeedingTool.h.

◆ m_pixelManager

const InDetDD::PixelDetectorManager* ActsTrk::GbtsSeedingTool::m_pixelManager = nullptr

private

Definition at line 87 of file GbtsSeedingTool.h.

◆ m_ptCoeff

Gaudi::Property<double> ActsTrk::GbtsSeedingTool::m_ptCoeff {this, "ptCoeff", 0.29997 * 1.9972 / 2.0, "~0.3*B/2 - assumes nominal field of 2*T"}

private

Definition at line 123 of file GbtsSeedingTool.h.

◆ m_PtMin

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_PtMin {this, "PtMin",1000.0, "pt limit used to caluclate triplet pT"}

private

Definition at line 120 of file GbtsSeedingTool.h.

◆ m_sigmaScattering

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_sigmaScattering

private

Initial value:

{this, "sigmaScattering", 2,

"how many sigmas of scattering angle should be considered"}

Definition at line 93 of file GbtsSeedingTool.h.

◆ m_tripletD0Max

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_tripletD0Max {this, "tripletD0Max",4.0, " D0 cut for triplets"}

private

Definition at line 113 of file GbtsSeedingTool.h.

◆ m_tripletPtMin

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_tripletPtMin {this, "tripletPtMin",m_PtMin * m_tripletPtMinFrac, "Limit on triplet pt"}

private

Definition at line 122 of file GbtsSeedingTool.h.

◆ m_tripletPtMinFrac

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_tripletPtMinFrac {this, "tripletPtMinFrac",0.3, "used to caluclate triplet pt"}

private

Definition at line 121 of file GbtsSeedingTool.h.

◆ m_useClusterWidth

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_useClusterWidth {this, "useClusterWidth",false, "bool for use of cluster width in loadSpacePoints function"}

private

Definition at line 106 of file GbtsSeedingTool.h.

◆ m_useEtaBinning

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_useEtaBinning {this, "useEtaBinning",true, "bool to use eta binning from geometry structure"}

private

Definition at line 110 of file GbtsSeedingTool.h.

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ seed_type

Constructor & Destructor Documentation

◆ GbtsSeedingTool()

◆ ~GbtsSeedingTool()

Member Function Documentation

◆ createSeeds()

◆ getCombinedID()

◆ initialize()

◆ LayerNumbering()

◆ logger()

◆ prepareConfiguration()

Member Data Documentation

◆ m_ConnectorInputFile

◆ m_cut_dcurv_max

◆ m_cut_dphi_max

◆ m_cut_tau_ratio_max

◆ m_doubletFilterRZ

◆ m_finderCfg

◆ m_gbtsGeo

◆ m_helixCutTolerance

◆ m_highland

◆ m_logger

◆ m_MaxEdges

◆ m_maxOuterRadius

◆ m_maxScatteringAngle2

◆ m_maxTripletBufferLength

◆ m_minDeltaRadius

◆ m_minPt

◆ m_nMaxPhiSlice

◆ m_phiSliceWidth

◆ m_pixelDetEleCollKey

◆ m_pixelId

◆ m_pixelManager

◆ m_ptCoeff

◆ m_PtMin

◆ m_sigmaScattering

◆ m_tripletD0Max

◆ m_tripletPtMin

◆ m_tripletPtMinFrac

◆ m_useClusterWidth

◆ m_useEtaBinning