#include <GbtsSeedingTool.h>

Inheritance diagram for ActsTrk::GbtsSeedingTool:

Collaboration diagram for ActsTrk::GbtsSeedingTool:

Classes
struct	GbtsSpacePoint

Public Types
using	seed_type = ActsTrk::Seed

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::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::SeedFinderGbtsConfig< ActsTrk::GbtsSeedingTool::GbtsSpacePoint >	m_finderCfg

std::unique_ptr< Acts::GbtsGeometry< ActsTrk::GbtsSeedingTool::GbtsSpacePoint > >	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< unsigned int >	m_maxSeedsPerSpM

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, "connector_input_file","binTables_ITK_RUN4.txt", "input file for making connector object"}

Gaudi::Property< bool >	m_LRTmode {this, "LRTmode",true, "bool for use of in run function"}

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"}

Gaudi::Property< float >	m_deltaInvHelixDiameter

Gaudi::Property< float >	m_impactWeightFactor

Gaudi::Property< float >	m_zOriginWeightFactor

Gaudi::Property< float >	m_compatSeedWeight

Gaudi::Property< float >	m_deltaRMin

Gaudi::Property< std::size_t >	m_compatSeedLimit

Gaudi::Property< float >	m_seedWeightIncrement {this, "seedWeightIncrement", 0}

Gaudi::Property< float >	m_numSeedIncrement {this, "numSeedIncrement", 3.40282e+38}

Gaudi::Property< bool >	m_seedConfirmationInFilter

Gaudi::Property< int >	m_maxSeedsPerSpMConf

Gaudi::Property< int >	m_maxQualitySeedsPerSpMConf

Gaudi::Property< bool >	m_useDeltaRorTopRadius

Gaudi::Property< float >	m_seedConfCentralZMin

Gaudi::Property< float >	m_seedConfCentralZMax

Gaudi::Property< float >	m_seedConfCentralRMax

Gaudi::Property< size_t >	m_seedConfCentralNTopLargeR

Gaudi::Property< size_t >	m_seedConfCentralNTopSmallR

Gaudi::Property< float >	m_seedConfCentralMinBottomRadius

Gaudi::Property< float >	m_seedConfCentralMaxZOrigin

Gaudi::Property< float >	m_seedConfCentralMinImpact

Gaudi::Property< float >	m_seedConfForwardZMin

Gaudi::Property< float >	m_seedConfForwardZMax

Gaudi::Property< float >	m_seedConfForwardRMax

Gaudi::Property< size_t >	m_seedConfForwardNTopLargeR

Gaudi::Property< size_t >	m_seedConfForwardNTopSmallR

Gaudi::Property< float >	m_seedConfForwardMinBottomRadius

Gaudi::Property< float >	m_seedConfForwardMaxZOrigin

Gaudi::Property< float >	m_seedConfForwardMinImpact

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 = ActsTrk::Seed

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 9 of file GbtsSeedingTool.cxx.

12 : base_class(type, name, parent)

13 {}

◆ ~GbtsSeedingTool()

virtual ActsTrk::GbtsSeedingTool::~GbtsSeedingTool ( )

virtualdefault

Member Function Documentation

◆ createSeeds()

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 47 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<std::unique_ptr<GbtsSeedingTool::GbtsSpacePoint>> SeedingToolSP ; 
     SeedingToolSP.reserve(
         spContainer.size()); 
     std::vector<Acts::GbtsSP<GbtsSeedingTool::GbtsSpacePoint>> 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
           auto StSp = std::make_unique<GbtsSeedingTool::GbtsSpacePoint>(spacePoint.x(), spacePoint.y(), spacePoint.z(), spacePoint.radius(), &spacePoint.externalSpacePoint());
         
           GbtsSpacePoints.emplace_back(StSp.get(), Gbts_id, combined_id); 
           SeedingToolSP.emplace_back(std::move(StSp)); 
       
         }
       
     }
  
     ATH_MSG_VERBOSE("Space points successfully assigned Gbts ID");
  
     Acts::SeedFinderGbts<GbtsSeedingTool::GbtsSpacePoint> finder =
       Acts::SeedFinderGbts<GbtsSeedingTool::GbtsSpacePoint>(m_finderCfg,
                                 *m_gbtsGeo,
                                 logger().cloneWithSuffix("Finder"));
     
     finder.loadSpacePoints(GbtsSpacePoints);
     //temporary solution until trigger ROIs implemented 
     Acts::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<GbtsSeedingTool::GbtsSpacePoint, 3ul>> groupSeeds = finder.createSeeds(internalRoi, *m_gbtsGeo);
  
     // Store seeds
  
     seedContainer.reserve(groupSeeds.size());
     for( Acts::Seed<GbtsSeedingTool::GbtsSpacePoint, 3ul>& seed: groupSeeds) {
       //turn interim into group seeds 
  
       const auto& spacepoints = seed.sp() ; 
       assert(spacepoints.size()==3) ;  
       const xAOD::SpacePoint* sp1 = spacepoints[0]->return_SP() ; 
       const xAOD::SpacePoint* sp2 = spacepoints[1]->return_SP() ; 
       const xAOD::SpacePoint* sp3 = spacepoints[2]->return_SP() ; 
  
       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 268 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 15 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.connector_input_file.c_str(), std::ifstream::in); //change to connector input file 
     // connector
     std::unique_ptr<Acts::GbtsConnector> inputConnector =  
         std::make_unique<Acts::GbtsConnector>(input_ifstream);
         
     m_gbtsGeo = std::make_unique<Acts::GbtsGeometry<ActsTrk::GbtsSeedingTool::GbtsSpacePoint>>( 
       m_finderCfg.m_layerGeometry, inputConnector);
  
     return StatusCode::SUCCESS;
   }

◆ LayerNumbering()

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

Definition at line 136 of file GbtsSeedingTool.cxx.

                                         {
     std::vector<std::size_t> count_vector;
     std::vector<Acts::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::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 217 of file GbtsSeedingTool.h.

217 { return *m_logger; }

◆ prepareConfiguration()

StatusCode ActsTrk::GbtsSeedingTool::prepareConfiguration ( )

private

Definition at line 198 of file GbtsSeedingTool.cxx.

   {
     // Configuration for Acts::SeedFilter
     Acts::SeedFilterConfig filterCfg;
     filterCfg.deltaInvHelixDiameter = m_deltaInvHelixDiameter;
     filterCfg.impactWeightFactor = m_impactWeightFactor;
     filterCfg.zOriginWeightFactor = m_zOriginWeightFactor;
     filterCfg.compatSeedWeight = m_compatSeedWeight;    
     filterCfg.deltaRMin = m_deltaRMin;
     filterCfg.maxSeedsPerSpM = m_maxSeedsPerSpM;
     filterCfg.compatSeedLimit = m_compatSeedLimit;
     filterCfg.seedWeightIncrement = m_seedWeightIncrement;
     filterCfg.numSeedIncrement = m_numSeedIncrement;
     filterCfg.seedConfirmation = m_seedConfirmationInFilter;
     filterCfg.maxSeedsPerSpMConf = m_maxSeedsPerSpMConf;
     filterCfg.maxQualitySeedsPerSpMConf = m_maxQualitySeedsPerSpMConf;
     filterCfg.useDeltaRorTopRadius = m_useDeltaRorTopRadius;
     filterCfg.centralSeedConfirmationRange.zMinSeedConf = m_seedConfCentralZMin;
     filterCfg.centralSeedConfirmationRange.zMaxSeedConf = m_seedConfCentralZMax;
     filterCfg.centralSeedConfirmationRange.rMaxSeedConf = m_seedConfCentralRMax;
     filterCfg.centralSeedConfirmationRange.nTopForLargeR = m_seedConfCentralNTopLargeR;
     filterCfg.centralSeedConfirmationRange.nTopForSmallR = m_seedConfCentralNTopSmallR;
     filterCfg.centralSeedConfirmationRange.seedConfMinBottomRadius = m_seedConfCentralMinBottomRadius;
     filterCfg.centralSeedConfirmationRange.seedConfMaxZOrigin = m_seedConfCentralMaxZOrigin;
     filterCfg.centralSeedConfirmationRange.minImpactSeedConf = m_seedConfCentralMinImpact;
     filterCfg.forwardSeedConfirmationRange.zMinSeedConf = m_seedConfForwardZMin;
     filterCfg.forwardSeedConfirmationRange.zMaxSeedConf = m_seedConfForwardZMax;
     filterCfg.forwardSeedConfirmationRange.rMaxSeedConf = m_seedConfForwardRMax;
     filterCfg.forwardSeedConfirmationRange.nTopForLargeR = m_seedConfForwardNTopLargeR;
     filterCfg.forwardSeedConfirmationRange.nTopForSmallR = m_seedConfForwardNTopSmallR;
     filterCfg.forwardSeedConfirmationRange.seedConfMinBottomRadius = m_seedConfForwardMinBottomRadius;
     filterCfg.forwardSeedConfirmationRange.seedConfMaxZOrigin = m_seedConfForwardMaxZOrigin;
     filterCfg.forwardSeedConfirmationRange.minImpactSeedConf = m_seedConfForwardMinImpact;
     
     // Configuration Acts::SeedFinderGbts
     m_finderCfg.seedFilter = std::make_shared<Acts::SeedFilter<GbtsSeedingTool::GbtsSpacePoint>>(filterCfg.toInternalUnits(),
                                                  logger().cloneWithSuffix("Filter")); 
  
     m_finderCfg.minPt = m_minPt;
     m_finderCfg.sigmaScattering = m_sigmaScattering;
     m_finderCfg.maxSeedsPerSpM = m_maxSeedsPerSpM;
     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.connector_input_file = m_connectorInputFile;
     m_finderCfg.m_LRTmode = m_LRTmode;
     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_compatSeedLimit

Gaudi::Property<std::size_t> ActsTrk::GbtsSeedingTool::m_compatSeedLimit

private

Initial value:

{this, "compatSeedLimit", 3,

"How often do you want to increase the weight of a seed for finding a compatible seed"}

Definition at line 159 of file GbtsSeedingTool.h.

◆ m_compatSeedWeight

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

private

Initial value:

{this, "compatSeedWeight", 100.,

"Seed weight increased by this value if a compatible seed has been found."}

Definition at line 155 of file GbtsSeedingTool.h.

◆ m_connectorInputFile

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

private

Definition at line 128 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 139 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 138 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 140 of file GbtsSeedingTool.h.

◆ m_deltaInvHelixDiameter

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

private

Initial value:

{this, "deltaInvHelixDiameter", 0.00003 * 1. / Acts::UnitConstants::mm,

"The allowed delta between two inverted seed radii for them to be considered compatible"}

Definition at line 149 of file GbtsSeedingTool.h.

◆ m_deltaRMin

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

private

Initial value:

{this, "deltaRMin", 20. * Acts::UnitConstants::mm,

"Minimum distance between compatible seeds to be considered for weight boost"}

Definition at line 157 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 133 of file GbtsSeedingTool.h.

◆ m_finderCfg

Acts::SeedFinderGbtsConfig<ActsTrk::GbtsSeedingTool::GbtsSpacePoint> ActsTrk::GbtsSeedingTool::m_finderCfg

private

Definition at line 100 of file GbtsSeedingTool.h.

◆ m_gbtsGeo

std::unique_ptr<Acts::GbtsGeometry<ActsTrk::GbtsSeedingTool::GbtsSpacePoint> > ActsTrk::GbtsSeedingTool::m_gbtsGeo = nullptr

private

Definition at line 102 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 122 of file GbtsSeedingTool.h.

◆ m_highland

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

private

Definition at line 119 of file GbtsSeedingTool.h.

◆ m_impactWeightFactor

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

private

Initial value:

{this, "impactWeightFactor", 100.,

"The transverse impact parameters (d0) is multiplied by this factor and subtracted from weight"}

Definition at line 151 of file GbtsSeedingTool.h.

◆ m_logger

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

private

logging instance

Definition at line 219 of file GbtsSeedingTool.h.

◆ m_LRTmode

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_LRTmode {this, "LRTmode",true, "bool for use of in run function"}

private

Definition at line 131 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 137 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 141 of file GbtsSeedingTool.h.

◆ m_maxQualitySeedsPerSpMConf

Gaudi::Property<int> ActsTrk::GbtsSeedingTool::m_maxQualitySeedsPerSpMConf

private

Initial value:

{this, "maxQualitySeedsPerSpMConf", 5,

"maximum number of quality seeds for each middle-bottom SP-duplet in seed confirmation if the limit is reached we check if there is a lower quality seed to be replaced"}

Definition at line 170 of file GbtsSeedingTool.h.

◆ m_maxScatteringAngle2

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

private

Definition at line 120 of file GbtsSeedingTool.h.

◆ m_maxSeedsPerSpM

Gaudi::Property<unsigned int> ActsTrk::GbtsSeedingTool::m_maxSeedsPerSpM

private

Initial value:

{this, "maxSeedsPerSpM", 5,

"For how many seeds can one SpacePoint be the middle SpacePoint"}

Definition at line 114 of file GbtsSeedingTool.h.

◆ m_maxSeedsPerSpMConf

Gaudi::Property<int> ActsTrk::GbtsSeedingTool::m_maxSeedsPerSpMConf

private

Initial value:

{this, "maxSeedsPerSpMConf", 5,

"maximum number of lower quality seeds in seed confirmation"}

Definition at line 168 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 136 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 134 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 108 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 126 of file GbtsSeedingTool.h.

◆ m_numSeedIncrement

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_numSeedIncrement {this, "numSeedIncrement", 3.40282e+38}

private

Definition at line 163 of file GbtsSeedingTool.h.

◆ m_phiSliceWidth

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

private

Definition at line 125 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 214 of file GbtsSeedingTool.h.

◆ m_pixelId

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

private

Definition at line 104 of file GbtsSeedingTool.h.

◆ m_pixelManager

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

private

Definition at line 105 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 145 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 142 of file GbtsSeedingTool.h.

◆ m_seedConfCentralMaxZOrigin

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

private

Initial value:

{this, "seedConfCentralMaxZOrigin", 150 * Acts::UnitConstants::mm,

"Maximum zOrigin in seed confirmation"}

Definition at line 191 of file GbtsSeedingTool.h.

◆ m_seedConfCentralMinBottomRadius

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

private

Initial value:

{this, "seedConfCentralMinBottomRadius", 60 * Acts::UnitConstants::mm,

"Minimum radius for bottom SP in seed confirmation"}

Definition at line 189 of file GbtsSeedingTool.h.

◆ m_seedConfCentralMinImpact

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

private

Initial value:

{this, "seedConfCentralMinImpact", 1. * Acts::UnitConstants::mm,

"Minimum impact parameter for seed confirmation"}

Definition at line 193 of file GbtsSeedingTool.h.

◆ m_seedConfCentralNTopLargeR

Gaudi::Property< size_t > ActsTrk::GbtsSeedingTool::m_seedConfCentralNTopLargeR

private

Initial value:

{this, "seedConfCentralNTopLargeR", 1,

"nTop for large R central seed confirmation"}

Definition at line 185 of file GbtsSeedingTool.h.

◆ m_seedConfCentralNTopSmallR

Gaudi::Property< size_t > ActsTrk::GbtsSeedingTool::m_seedConfCentralNTopSmallR

private

Initial value:

{this, "seedConfCentralNTopSmallR", 2,

"nTop for small R central seed confirmation"}

Definition at line 187 of file GbtsSeedingTool.h.

◆ m_seedConfCentralRMax

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

private

Initial value:

{this, "seedConfCentralRMax", 140. * Acts::UnitConstants::mm,

"maximum r for central seed confirmation "}

Definition at line 183 of file GbtsSeedingTool.h.

◆ m_seedConfCentralZMax

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

private

Initial value:

{this, "seedConfCentralZMax", 250. * Acts::UnitConstants::mm,

"maximum z for central seed confirmation "}

Definition at line 181 of file GbtsSeedingTool.h.

◆ m_seedConfCentralZMin

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

private

Initial value:

{this, "seedConfCentralZMin", -250. * Acts::UnitConstants::mm,

"minimum z for central seed confirmation "}

Definition at line 179 of file GbtsSeedingTool.h.

◆ m_seedConfForwardMaxZOrigin

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

private

Initial value:

{this, "seedConfForwardMaxZOrigin", 150 * Acts::UnitConstants::mm,

"Maximum zOrigin in seed confirmation"}

Definition at line 208 of file GbtsSeedingTool.h.

◆ m_seedConfForwardMinBottomRadius

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

private

Initial value:

{this, "seedConfForwardMinBottomRadius", 60 * Acts::UnitConstants::mm,

"Minimum radius for bottom SP in seed confirmation"}

Definition at line 206 of file GbtsSeedingTool.h.

◆ m_seedConfForwardMinImpact

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

private

Initial value:

{this, "seedConfForwardMinImpact", 1. * Acts::UnitConstants::mm,

"Minimum impact parameter for seed confirmation"}

Definition at line 210 of file GbtsSeedingTool.h.

◆ m_seedConfForwardNTopLargeR

Gaudi::Property< size_t > ActsTrk::GbtsSeedingTool::m_seedConfForwardNTopLargeR

private

Initial value:

{this, "seedConfForwardNTopLargeR", 1,

"nTop for large R forward seed confirmation"}

Definition at line 202 of file GbtsSeedingTool.h.

◆ m_seedConfForwardNTopSmallR

Gaudi::Property< size_t > ActsTrk::GbtsSeedingTool::m_seedConfForwardNTopSmallR

private

Initial value:

{this, "seedConfForwardNTopSmallR", 2,

"nTop for small R forward seed confirmation"}

Definition at line 204 of file GbtsSeedingTool.h.

◆ m_seedConfForwardRMax

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

private

Initial value:

{this, "seedConfForwardRMax", 140. * Acts::UnitConstants::mm,

"maximum r for forward seed confirmation "}

Definition at line 200 of file GbtsSeedingTool.h.

◆ m_seedConfForwardZMax

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

private

Initial value:

{this, "seedConfForwardZMax", 3000. * Acts::UnitConstants::mm,

"maximum z for forward seed confirmation "}

Definition at line 198 of file GbtsSeedingTool.h.

◆ m_seedConfForwardZMin

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

private

Initial value:

{this, "seedConfForwardZMin", -3000. * Acts::UnitConstants::mm,

"minimum z for forward seed confirmation "}

Definition at line 196 of file GbtsSeedingTool.h.

◆ m_seedConfirmationInFilter

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_seedConfirmationInFilter

private

Initial value:

{this, "seedConfirmationInFilter", true,

"Seed Confirmation"}

Definition at line 165 of file GbtsSeedingTool.h.

◆ m_seedWeightIncrement

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_seedWeightIncrement {this, "seedWeightIncrement", 0}

private

Definition at line 162 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 111 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 135 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 144 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 143 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 127 of file GbtsSeedingTool.h.

◆ m_useDeltaRorTopRadius

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_useDeltaRorTopRadius

private

Initial value:

{this, "useDeltaRorTopRadius", true,

"use deltaR between top and middle SP instead of top radius to search for compatible SPs"}

Definition at line 173 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 132 of file GbtsSeedingTool.h.

◆ m_zOriginWeightFactor

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

private

Initial value:

{this, "zOriginWeightFactor", 1.,

"The logitudinal impact parameters (z0) is multiplied by this factor and subtracted from weight"}

Definition at line 153 of file GbtsSeedingTool.h.

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

Classes

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_compatSeedLimit

◆ m_compatSeedWeight

◆ m_connectorInputFile

◆ m_cut_dcurv_max

◆ m_cut_dphi_max

◆ m_cut_tau_ratio_max

◆ m_deltaInvHelixDiameter

◆ m_deltaRMin

◆ m_doubletFilterRZ

◆ m_finderCfg

◆ m_gbtsGeo

◆ m_helixCutTolerance

◆ m_highland

◆ m_impactWeightFactor

◆ m_logger

◆ m_LRTmode

◆ m_MaxEdges

◆ m_maxOuterRadius

◆ m_maxQualitySeedsPerSpMConf

◆ m_maxScatteringAngle2

◆ m_maxSeedsPerSpM

◆ m_maxSeedsPerSpMConf

◆ m_maxTripletBufferLength

◆ m_minDeltaRadius

◆ m_minPt

◆ m_nMaxPhiSlice

◆ m_numSeedIncrement

◆ m_phiSliceWidth

◆ m_pixelDetEleCollKey

◆ m_pixelId

◆ m_pixelManager

◆ m_ptCoeff

◆ m_PtMin

◆ m_seedConfCentralMaxZOrigin

◆ m_seedConfCentralMinBottomRadius

◆ m_seedConfCentralMinImpact

◆ m_seedConfCentralNTopLargeR

◆ m_seedConfCentralNTopSmallR

◆ m_seedConfCentralRMax

◆ m_seedConfCentralZMax

◆ m_seedConfCentralZMin

◆ m_seedConfForwardMaxZOrigin

◆ m_seedConfForwardMinBottomRadius

◆ m_seedConfForwardMinImpact

◆ m_seedConfForwardNTopLargeR

◆ m_seedConfForwardNTopSmallR

◆ m_seedConfForwardRMax

◆ m_seedConfForwardZMax

◆ m_seedConfForwardZMin

◆ m_seedConfirmationInFilter

◆ m_seedWeightIncrement

◆ m_sigmaScattering

◆ m_tripletD0Max

◆ m_tripletPtMin

◆ m_tripletPtMinFrac

◆ m_useClusterWidth

◆ m_useDeltaRorTopRadius

◆ m_useEtaBinning

◆ m_zOriginWeightFactor