ITk::SiSpacePointsSeedMaker Class Reference

Class for track candidates generation using space points information for standard Atlas geometry. More...

#include <ITkSiSpacePointsSeedMaker.h>

Inheritance diagram for ITk::SiSpacePointsSeedMaker:

Public Member Functions
Standard tool methods
	SiSpacePointsSeedMaker (const std::string &, const std::string &, const IInterface *)
virtual	~SiSpacePointsSeedMaker ()=default
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
Methods to initialize tool for new event or region
virtual void	newEvent (const EventContext &ctx, EventData &data, int iteration) const override
virtual void	newRegion (const EventContext &ctx, EventData &data, const std::vector< IdentifierHash > &vPixel, const std::vector< IdentifierHash > &vStrip) const override
virtual void	newRegion (const EventContext &ctx, EventData &data, const std::vector< IdentifierHash > &vPixel, const std::vector< IdentifierHash > &vStrip, const IRoiDescriptor &iRD) const override
Methods to initilize different strategies of seeds production
virtual void	find2Sp (EventData &data, const std::list< Trk::Vertex > &lv) const override
	with two space points with or without vertex constraint
virtual void	find3Sp (const EventContext &ctx, EventData &data, const std::list< Trk::Vertex > &lv) const override
	with three space points with or without vertex constraint
virtual void	find3Sp (const EventContext &ctx, EventData &data, const std::list< Trk::Vertex > &lv, const double *zVertex) const override
	with three space points with or without vertex constraint with information about min and max Z of the vertex
virtual void	findVSp (const EventContext &ctx, EventData &data, const std::list< Trk::Vertex > &lv) const override
	with variable number space points with or without vertex constraint Variable means (2,3,4,....) any number space points
Iterator through seeds pseudo collection
produced accordingly methods find
virtual const InDet::SiSpacePointsSeed *	next (const EventContext &ctx, EventData &data) const override
virtual void	writeNtuple (const InDet::SiSpacePointsSeed *seed, const Trk::Track *track, int seedType, long eventNumber) const override
virtual bool	getWriteNtupleBoolProperty () const override

Private Attributes
Data handles
SG::ReadHandleKey< SpacePointContainer >	m_spacepointsStrip {this, "SpacePointsStripName", "ITkStripSpacePoints", "Strip space points container"}
SG::ReadHandleKey< SpacePointContainer >	m_spacepointsPixel {this, "SpacePointsPixelName", "ITkPixelSpacePoints", "Pixel space points container"}
SG::ReadHandleKey< SpacePointOverlapCollection >	m_spacepointsOverlap {this, "SpacePointsOverlapName", "OverlapSpacePoints"}
SG::ReadHandleKey< Trk::PRDtoTrackMap >	m_prdToTrackMap {this,"PRDtoTrackMap","","option PRD-to-track association"}
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCondObjInputKey
Properties, which will not be changed after construction
BooleanProperty	m_pixel {this, "usePixel", true}
BooleanProperty	m_strip {this, "useStrip", true}
BooleanProperty	m_useOverlap {this, "useOverlapSpCollection", true}
IntegerProperty	m_maxsize {this, "maxSize", 10000}
IntegerProperty	m_maxsizeSP {this, "maxSizeSP", 4096}
IntegerProperty	m_maxOneSize {this, "maxSeedsForSpacePoint", 5}
FloatProperty	m_etamax {this, "etaMax", 2.7}
FloatProperty	m_r1minv {this, "minVRadius1", 0.}
FloatProperty	m_r1maxv {this, "maxVRadius1", 60.}
FloatProperty	m_r2minv {this, "minVRadius2", 70.}
FloatProperty	m_r2maxv {this, "maxVRadius2", 200.}
FloatProperty	m_drmin {this, "mindRadius", 5.}
FloatProperty	m_drmax {this, "maxdRadius", 300.}
FloatProperty	m_zmin {this, "minZ", -250.}
FloatProperty	m_zmax {this , "maxZ", +250.}
FloatProperty	m_r_rmin {this, "radMin", 0.}
FloatProperty	m_binSizeR {this, "radStep", 2.}
FloatProperty	m_dzver {this, "maxdZver", 5.}
FloatProperty	m_dzdrver {this, "maxdZdRver", 0.02}
FloatProperty	m_maxdImpact {this, "maxdImpact", 10.}
FloatProperty	m_maxdImpactSSS {this, "maxdImpactSSS", 20.}
FloatProperty	m_dzmaxPPP {this, "dZmaxForPPPSeeds", 600.}
FloatProperty	m_maxScore {this, "maximumAcceptedSeedScore", 100.}
IntegerProperty	m_maxOneSizeSSS {this, "maxSeedsForSpacePointStrips", 5}
IntegerProperty	m_maxOneSizePPP {this, "maxSeedsForSpacePointPixels", 5}
BooleanProperty	m_alwaysKeepConfirmedPixelSeeds {this, "alwaysKeepConfirmedPixelSeeds", false}
BooleanProperty	m_alwaysKeepConfirmedStripSeeds {this, "alwaysKeepConfirmedStripSeeds", false}
BooleanProperty	m_fastTracking {this, "useFastTracking", false}
FloatProperty	m_seedScoreBonusPPP {this, "seedScoreBonusPPP", -200.}
FloatProperty	m_seedScoreBonusSSS {this, "seedScoreBonusSSS", -400.}
BooleanProperty	m_optimisePhiBinning {this, "optimisePhiBinning", true}
FloatProperty	m_rminSSS {this, "radMinSSS", 400.}
FloatProperty	m_rmaxSSS {this, "radMaxSSS", 1000.}
BooleanProperty	m_isLRT {this, "isLRT", false}
FloatProperty	m_drminPPP {this, "mindRadiusPPP", 6.}
FloatProperty	m_drmaxPPP {this, "maxdRadiusPPP", 150.}
FloatProperty	m_zmaxPPP {this, "maxZPPP", 2700.}
FloatProperty	m_drminSSS {this, "mindRadiusSSS", 20.}
FloatProperty	m_drmaxSSS {this, "maxdRadiusSSS", 300.}
FloatProperty	m_zmaxSSS {this, "maxZSSS", 2700.}
FloatProperty	m_dImpactCutSlopeUnconfirmedSSS {this, "dImpactCutSlopeUnconfirmedSSS", 1.0}
FloatProperty	m_dImpactCutSlopeUnconfirmedPPP {this, "dImpactCutSlopeUnconfirmedPPP", 0.}
FloatProperty	m_seedScoreBonusConfirmationSeed {this, "seedScoreBonusConfirmationSeed", -200.}
BooleanProperty	m_useSeedConfirmation {this, "useSeedConfirmation", false}
Properties, which will be updated in initialize
FloatProperty	m_etamin {this, "etaMin", 0.}
FloatProperty	m_r_rmax {this, "radMax", 1100.}
FloatProperty	m_ptmin {this, "pTmin", 500.}
FloatProperty	m_umax {this, "minSeedsQuality", 0.}
Properties, which will be updated in event methods, checketa is prepared in EventData.
BooleanProperty	m_checketa {this, "checkEta", false}
Data members, which are updated only in initialize
int	m_outputlevel {0}
float	m_dzdrmin0 {0.}
float	m_dzdrmax0 {0.}
float	m_ipt {0.}
float	m_ipt2 {0.}
float	m_COF {134 * .05f * 9}
float	m_dzMaxFast {200.}
float	m_R2MaxFast {2025}
float	m_rmaxPPP {140.}
float	m_dzmaxSSS {900.}
float	m_drminSeedConf {5.}
Properties of writeNTuple for validation purpose
Gaudi::Property< bool >	m_writeNtuple {this, "WriteNtuple", false, "Flag to write Validation Ntuples"}
ServiceHandle< ITHistSvc >	m_thistSvc
	Flag to write validation ntuples. Turned off by default.
TTree *	m_outputTree
std::mutex	m_mutex
std::string	m_treeName
std::string	m_treeFolder
float m_d0	ATLAS_THREAD_SAFE = 0
float m_z0	ATLAS_THREAD_SAFE = 0
float m_pt	ATLAS_THREAD_SAFE = 0
float m_eta	ATLAS_THREAD_SAFE = 0
double m_x1	ATLAS_THREAD_SAFE = 0
double m_x2	ATLAS_THREAD_SAFE = 0
double m_x3	ATLAS_THREAD_SAFE = 0
double m_y1	ATLAS_THREAD_SAFE = 0
double m_y2	ATLAS_THREAD_SAFE = 0
double m_y3	ATLAS_THREAD_SAFE = 0
double m_z1	ATLAS_THREAD_SAFE = 0
double m_z2	ATLAS_THREAD_SAFE = 0
double m_z3	ATLAS_THREAD_SAFE = 0
double m_r1	ATLAS_THREAD_SAFE = 0
double m_r2	ATLAS_THREAD_SAFE = 0
double m_r3	ATLAS_THREAD_SAFE = 0
float m_quality	ATLAS_THREAD_SAFE = 0
int m_type	ATLAS_THREAD_SAFE = 0
double m_dzdr_t	ATLAS_THREAD_SAFE = 0
double m_dzdr_b	ATLAS_THREAD_SAFE = 0
bool m_givesTrack	ATLAS_THREAD_SAFE = 0
float m_trackPt	ATLAS_THREAD_SAFE = 0
float m_trackEta	ATLAS_THREAD_SAFE = 0
long m_eventNumber	ATLAS_THREAD_SAFE = 0
Binning parameters
int	m_nBinsR {0}
	number of bins in the radial coordinate
int	m_maxPhiBinPPP {0}
	number of bins in phi
float	m_inverseBinSizePhiPPP {0}
	cache the inverse bin size in phi which we use - needed to evaluate phi bin locations
int	m_maxPhiBinSSS {0}
float	m_inverseBinSizePhiSSS {0}
int	m_maxBinPhiVertex {0}
float	m_inverseBinSizePhiVertex {0}
float	m_seedScoreThresholdPPPConfirmationSeed {0.}
	Seed score thresholds defined based on the modifiers defined as configurables above.
float	m_seedScoreThresholdSSSConfirmationSeed {0.}
	max (score is assigned negative sign) score for SSS seeds with confirmation seed requirement.
std::array< int, arraySizePhiZ >	m_nNeighbourCellsBottomPPP {}
	arrays associating bins to each other for SP formation
std::array< int, arraySizePhiZ >	m_nNeighbourCellsTopPPP {}
	number of neighbouring phi-z bins to consider when looking for "top SP" candidates for each phi-z bin
std::array< std::array< int, arraySizeNeighbourBins >, arraySizePhiZ >	m_neighbourCellsBottomPPP {}
	mapping of neighbour cells in the 2D phi-z binning to consider for the "bottom SP" search for central SPs in each phi-z bin. Number of valid entries stored in m_nNeighboursPhiZbottom
std::array< std::array< int, arraySizeNeighbourBins >, arraySizePhiZ >	m_neighbourCellsTopPPP {}
	mapping of neighbour cells in the 2D phi-z binning to consider for the "top SP" search for central SPs in each phi-z bin. Number of valid entries stored in m_nNeighboursPhiZtop
std::array< int, arraySizePhiZ >	m_nNeighbourCellsBottomSSS {}
std::array< int, arraySizePhiZ >	m_nNeighbourCellsTopSSS {}
std::array< std::array< int, arraySizeNeighbourBins >, arraySizePhiZ >	m_neighbourCellsBottomSSS {}
std::array< std::array< int, arraySizeNeighbourBins >, arraySizePhiZ >	m_neighbourCellsTopSSS {}
std::array< int, arraySizePhiZV >	m_nNeighboursVertexPhiZ {}
std::array< std::array< int, arraySizeNeighbourBinsVertex >, arraySizePhiZV >	m_neighboursVertexPhiZ {}

Print internal tool parameters and status
enum	Size {   arraySizePhi =200 , arraySizeZ =11 , arraySizePhiZ =arraySizePhi*arraySizeZ , arraySizeNeighbourBins =9 ,   arraySizePhiV =100 , arraySizeZV =3 , arraySizePhiZV =arraySizePhiV*arraySizeZV , arraySizeNeighbourBinsVertex =6 }
	enum for array sizes Note that this stores the maximum capacities, the actual binnings do not always use the full size. More...
virtual MsgStream &	dump (EventData &data, MsgStream &out) const override

Disallow default instantiation, copy, assignment
	SiSpacePointsSeedMaker ()=delete
	SiSpacePointsSeedMaker (const SiSpacePointsSeedMaker &)=delete
SiSpacePointsSeedMaker &	operator= (const SiSpacePointsSeedMaker &)=delete
MsgStream &	dumpConditions (EventData &data, MsgStream &out) const
void	buildFrameWork ()
void	buildBeamFrameWork (EventData &data) const
SiSpacePointForSeed *	newSpacePoint (EventData &data, const Trk::SpacePoint *const &sp) const
	Create a SiSpacePointForSeed from the space point.
SiSpacePointForSeed *	newSpacePoint (EventData &data, const Trk::SpacePoint *const &sp, std::span< float, 15 > r, bool usePixStripInform=false) const
void	newOneSeed (EventData &data, SiSpacePointForSeed *&, SiSpacePointForSeed *&, SiSpacePointForSeed *&, float, float) const
void	newOneSeedQ (EventData &data, SiSpacePointForSeed *&, SiSpacePointForSeed *&, SiSpacePointForSeed *&, float, float) const
void	newOneSeedWithCurvaturesComparison (EventData &data, SiSpacePointForSeed *&, SiSpacePointForSeed *&, float) const
void	fillLists (EventData &data) const
void	production2Sp (EventData &data) const
void	production3Sp (EventData &data) const
void	production3SpSSS (EventData &data, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_bottomCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_endBottomCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_topCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_endTopCands, const int numberBottomCells, const int numberTopCells, int &nseed) const
	: Seed production from space points.
void	production3SpPPP (EventData &data, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_bottomCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_endBottomCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_topCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_endTopCands, const int numberBottomCells, const int numberTopCells, int &nseed) const
void	production3SpTrigger (EventData &, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &, const int, const int, int &) const
	as above, but for the trigger
void	newOneSeedWithCurvaturesComparisonSSS (EventData &data, SiSpacePointForSeed *&SPb, SiSpacePointForSeed *&SP0, float Zob) const
	This creates all possible seeds with the passed central and bottom SP, using all top SP candidates which are stored in the data.CmSp member.
void	newOneSeedWithCurvaturesComparisonPPP (EventData &data, SiSpacePointForSeed *&SPb, SiSpacePointForSeed *&SP0, float Zob) const
void	newOneSeedWithCurvaturesComparisonSeedConfirmation (EventData &data, SiSpacePointForSeed *&SPb, SiSpacePointForSeed *&SP0, float Zob) const
bool	isConfirmedSeed (const SiSpacePointForSeed *bottomSP, const SiSpacePointForSeed *topSP, float quality) const
	Helper method to determine if a seed is 'confirmed' - this means that a second seed exists with compatible curvature, the same bottom and central SP, but a different third SP.
void	sort (std::vector< InDet::FloatInt > &s, int start, int size) const
bool	newVertices (EventData &data, const std::list< Trk::Vertex > &) const
void	findNext (EventData &data) const
bool	isZCompatible (EventData &data, float Zv, float R, float T) const
bool	isUsed (const Trk::SpacePoint *, const Trk::PRDtoTrackMap &prd_to_track_map) const
void	initializeEventData (EventData &data, const EventContext &ctx) const
static MsgStream &	dumpEvent (EventData &data, MsgStream &out)
static void	buildConnectionMaps (std::array< int, arraySizePhiZ > &nNeighbourCellsBottom, std::array< int, arraySizePhiZ > &nNeighbourCellsTop, std::array< std::array< int, arraySizeNeighbourBins >, arraySizePhiZ > &neighbourCellsBottom, std::array< std::array< int, arraySizeNeighbourBins >, arraySizePhiZ > &neighbourCellsTop, int maxPhiBin, bool isSSS)
static void	buildConnectionMapsVertex (std::array< int, arraySizePhiZV > &nNeighbourCells, std::array< std::array< int, arraySizeNeighbourBinsVertex >, arraySizePhiZV > &neighbourCells, int maxPhiBin)
	Build maps for radius-azimuthal-Z sorted collections for Z Similar logic to the above, just simplified as only 3 regions in z exist!
static float	azimuthalStep (const float pTmin, const float maxd0, const float Rmin, const float Rmax)
	Determine the expected azimuthal trajectory displacement in phi in presence of the magnetic field for a particle with momentum pTmin and impact parameter maxd0, moving from a radial coordinate Rmin outward to Rmax.
static void	newSeed (EventData &data, SiSpacePointForSeed *&, SiSpacePointForSeed *&, float)
static void	fillSeeds (EventData &data)
static void	pixInform (const Trk::SpacePoint *sp, float *r)
static void	stripInform (EventData &data, const Trk::SpacePoint *sp, float *r)
static void	erase (EventData &data)
static void	convertToBeamFrameWork (EventData &data, const Trk::SpacePoint *, float *)

Detailed Description

Class for track candidates generation using space points information for standard Atlas geometry.

In AthenaMT, event dependent cache inside ITk::SiSpacePointsSeedMaker is not preferred. SiSpacePointsSeedMakerEventData = EventData class holds event dependent data for ITk::SiSpacePointsSeedMaker. Its object is instantiated in SiSPSeededTrackFinder::execute.

Definition at line 76 of file ITkSiSpacePointsSeedMaker.h.

Member Enumeration Documentation

Size

enum ITk::SiSpacePointsSeedMaker::Size

private

enum for array sizes Note that this stores the maximum capacities, the actual binnings do not always use the full size.

See data members below for the actual binning paramaters, which are determined in buildFramework.

Enumerator
arraySizePhi	capacity of the 1D phi arrays
arraySizeZ	capacity of the 1D z arrays
arraySizePhiZ	capacity for the 2D phi-z arrays
arraySizeNeighbourBins	array size to store neighbouring phi-z-regions in the seed finding
arraySizePhiV	array size in phi for vertexing
arraySizeZV	array size in z for vertexing
arraySizePhiZV	array size in phi-Z 2D for the vertexing
arraySizeNeighbourBinsVertex

Definition at line 151 of file ITkSiSpacePointsSeedMaker.h.

              {arraySizePhi=200,     
                arraySizeZ=11,       
                arraySizePhiZ=arraySizePhi*arraySizeZ,   
                arraySizeNeighbourBins=9,  
                arraySizePhiV=100,         
                arraySizeZV=3,             
                arraySizePhiZV=arraySizePhiV*arraySizeZV,      
                arraySizeNeighbourBinsVertex=6};       

Constructor & Destructor Documentation

SiSpacePointsSeedMaker() [1/3]

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

Definition at line 37 of file ITkSiSpacePointsSeedMaker.cxx.

    : base_class(t, n, p),
    m_thistSvc("THistSvc", n),
    m_outputTree(nullptr),
    m_treeName(""),
    m_treeFolder("/valNtuples/")
{
  if (m_maxOneSize > 0)
  {
    m_maxOneSizeSSS = m_maxOneSize;
    m_maxOneSizePPP = m_maxOneSize;
  }
}

~SiSpacePointsSeedMaker()

virtual ITk::SiSpacePointsSeedMaker::~SiSpacePointsSeedMaker ( )

virtualdefault

SiSpacePointsSeedMaker() [2/3]

ITk::SiSpacePointsSeedMaker::SiSpacePointsSeedMaker ( )

privatedelete

SiSpacePointsSeedMaker() [3/3]

ITk::SiSpacePointsSeedMaker::SiSpacePointsSeedMaker ( const SiSpacePointsSeedMaker & )

privatedelete

Member Function Documentation

azimuthalStep()

float ITk::SiSpacePointsSeedMaker::azimuthalStep ( const float pTmin, const float maxd0, const float Rmin, const float Rmax )

staticprivate

Determine the expected azimuthal trajectory displacement in phi in presence of the magnetic field for a particle with momentum pTmin and impact parameter maxd0, moving from a radial coordinate Rmin outward to Rmax.

This method is used to determine the optimal binning of the phi-z regions we consider in the seed making, to ensure we contain the hits from our softest tracks in a set of consecutive bins.

Parameters

[in]	pTmin	minimum pt cut applied in MeV
[in]	maxD0	maximum d0 allowed
[in]	Rmin	starting radius for trajectory displacement
[in]	Rmax	end radius for trajectory displacement

here we approximate the largest curvature that can be expected for the seeds we build using R[mm] ~ pT[MeV] / (0.3 * B[T]), with B == 2T

for LRT, the maximum allowed d0 may be larger than the radius at which the innermost hit is possible. In that case, our "worst case" trajectory generating the largest phi displacement will be the one with a hit at Rmin and d0 == Rmin.

Definition at line 1131 of file ITkSiSpacePointsSeedMaker.cxx.

{
  float Rm = pTmin / .6;

  float worstCaseD0 = maxd0;
  if (maxd0 > Rmin)
    worstCaseD0 = Rmin;
 
  float sI = std::abs(std::asin(worstCaseD0 / Rmin) - std::asin(worstCaseD0 / Rmax));
  float sF = std::abs(std::asin(std::min(1., Rmax / (2. * Rm))) -
                      std::asin(std::min(1., Rmin / (2. * Rm))));
  return sI + sF;
}

buildBeamFrameWork()

void ITk::SiSpacePointsSeedMaker::buildBeamFrameWork ( EventData & data ) const

private

Definition at line 1158 of file ITkSiSpacePointsSeedMaker.cxx.

{
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{m_beamSpotKey};
 
  const Amg::Vector3D &cb = beamSpotHandle->beamPos();
  double tx = std::tan(beamSpotHandle->beamTilt(0));
  double ty = std::tan(beamSpotHandle->beamTilt(1));
 
  double phi = std::atan2(ty, tx);
  double theta = std::acos(1. / std::sqrt(1. + tx * tx + ty * ty));
  double sinTheta = std::sin(theta);
  double cosTheta = std::cos(theta);
  double sinPhi = std::sin(phi);
  double cosPhi = std::cos(phi);
 
  data.xbeam[0] = static_cast<float>(cb.x());
  data.xbeam[1] = static_cast<float>(cosTheta * cosPhi * cosPhi + sinPhi * sinPhi);
  data.xbeam[2] = static_cast<float>(cosTheta * sinPhi * cosPhi - sinPhi * cosPhi);
  data.xbeam[3] = -static_cast<float>(sinTheta * cosPhi);
 
  data.ybeam[0] = static_cast<float>(cb.y());
  data.ybeam[1] = static_cast<float>(cosTheta * cosPhi * sinPhi - sinPhi * cosPhi);
  data.ybeam[2] = static_cast<float>(cosTheta * sinPhi * sinPhi + cosPhi * cosPhi);
  data.ybeam[3] = -static_cast<float>(sinTheta * sinPhi);
 
  data.zbeam[0] = static_cast<float>(cb.z());
  data.zbeam[1] = static_cast<float>(sinTheta * cosPhi);
  data.zbeam[2] = static_cast<float>(sinTheta * sinPhi);
  data.zbeam[3] = static_cast<float>(cosTheta);
}

buildConnectionMaps()

void ITk::SiSpacePointsSeedMaker::buildConnectionMaps ( std::array< int, arraySizePhiZ > & nNeighbourCellsBottom, std::array< int, arraySizePhiZ > & nNeighbourCellsTop, std::array< std::array< int, arraySizeNeighbourBins >, arraySizePhiZ > & neighbourCellsBottom, std::array< std::array< int, arraySizeNeighbourBins >, arraySizePhiZ > & neighbourCellsTop, int maxPhiBin, bool isSSS )

staticprivate

Build maps for radius-azimuthal-Z sorted collections. Here, we associate which bins are 'connected' to a given phi-Z bin for the seeding

< loop around at edges of range

< loop around at edges of range

For each azimuthal region loop through all Z regions

we always include the two neighbouring phi bins for the top / bottom space point search

in addition, we usually add at least one neighbouring slice in Z. This depends on where we are in the detector. Guide for the following: z == 5: central z region, |z|<250mm 0 1 2 3 4 5 6 7 8 9 10 z bin index --------------------------------------> Z[mm] Z=-2500 IP,Z=0 Z=+2500

for the top SP search in positive z, if we are not in the outermost z region, we include the neighbouring Z region on the right (away from the IP). In z = 10, the most forward, we do not have such a 'right side' neighbour we can add

for the bottom SP in negative non-central z, we include the neighbouring z region on the right (towards the IP) in the bottom neighbour search

z bins 3 / 7: 450mm < |z| < 925mm.: also include the central z region in the bottom SP search.
likely for PPP seeds with hits in pixel barrel + endcaps

Only used for strip seeds

Definition at line 947 of file ITkSiSpacePointsSeedMaker.cxx.

{

 
  for (int phiBin = 0; phiBin <= maxPhiBin; ++phiBin)
  {
 
    int phiBelow = phiBin - 1;
    if (phiBelow < 0) phiBelow = maxPhiBin; 
 
    int phiAbove = phiBin + 1;
    if (phiAbove > maxPhiBin) phiAbove = 0; 

    for (int z = 0; z < arraySizeZ; ++z) {

 
      int twoDbinSamePhi = phiBin * arraySizeZ + z;
      int twoDbinLowerPhi = phiBelow * arraySizeZ + z;
      int twoDbinHigherPhi = phiAbove * arraySizeZ + z;
 
      nNeighbourCellsBottom[twoDbinSamePhi] = 3;
      nNeighbourCellsTop[twoDbinSamePhi] = 3;
 
      neighbourCellsBottom[twoDbinSamePhi][0] = twoDbinSamePhi;
      neighbourCellsTop[twoDbinSamePhi][0] = twoDbinSamePhi;
 
      neighbourCellsBottom[twoDbinSamePhi][1] = twoDbinLowerPhi;
      neighbourCellsTop[twoDbinSamePhi][1] = twoDbinLowerPhi;
 
      neighbourCellsBottom[twoDbinSamePhi][2] = twoDbinHigherPhi;
      neighbourCellsTop[twoDbinSamePhi][2] = twoDbinHigherPhi;

      if (z == 5)
      {
        nNeighbourCellsTop[twoDbinSamePhi] = 9;
        // in the central z region, we include the two neighbouring
        // z slices for the top neighbour search
 
        neighbourCellsTop[twoDbinSamePhi][3] = twoDbinSamePhi + 1;
        neighbourCellsTop[twoDbinSamePhi][4] = twoDbinLowerPhi + 1;
        neighbourCellsTop[twoDbinSamePhi][5] = twoDbinHigherPhi + 1;
        neighbourCellsTop[twoDbinSamePhi][6] = twoDbinSamePhi - 1;
        neighbourCellsTop[twoDbinSamePhi][7] = twoDbinLowerPhi - 1;
        neighbourCellsTop[twoDbinSamePhi][8] = twoDbinHigherPhi - 1;
      }
      // z > 5: positive z values, |z| > 250mm
      else if (z > 5)
      {
        // for the bottom SP search in positive non-central z, we include the
        // neighbouring Z region on the left (towards the IP) in the bottom
        // neighbour search
        nNeighbourCellsBottom[twoDbinSamePhi] = 6;
        neighbourCellsBottom[twoDbinSamePhi][3] = twoDbinSamePhi - 1;
        neighbourCellsBottom[twoDbinSamePhi][4] = twoDbinLowerPhi - 1;
        neighbourCellsBottom[twoDbinSamePhi][5] = twoDbinHigherPhi - 1;
 
        if (z < 10)
        {
          nNeighbourCellsTop[twoDbinSamePhi] = 6;
          neighbourCellsTop[twoDbinSamePhi][3] = twoDbinSamePhi + 1;
          neighbourCellsTop[twoDbinSamePhi][4] = twoDbinLowerPhi + 1;
          neighbourCellsTop[twoDbinSamePhi][5] = twoDbinHigherPhi + 1;
        }
      }
      // z < 5: negative z values, |z| > 250mm
      else
      {
        nNeighbourCellsBottom[twoDbinSamePhi] = 6;
        neighbourCellsBottom[twoDbinSamePhi][3] = twoDbinSamePhi + 1;
        neighbourCellsBottom[twoDbinSamePhi][4] = twoDbinLowerPhi + 1;
        neighbourCellsBottom[twoDbinSamePhi][5] = twoDbinHigherPhi + 1;
 
        if (z > 0)
        {
          // if there is a z region on the left (away from the IP), we include it in the top
          // neighbour search
          nNeighbourCellsTop[twoDbinSamePhi] = 6;
          neighbourCellsTop[twoDbinSamePhi][3] = twoDbinSamePhi - 1;
          neighbourCellsTop[twoDbinSamePhi][4] = twoDbinLowerPhi - 1;
          neighbourCellsTop[twoDbinSamePhi][5] = twoDbinHigherPhi - 1;
        }
      }

      if (isSSS)
      {
        if (z == 3)
        {
          nNeighbourCellsBottom[twoDbinSamePhi] = 9;
          neighbourCellsBottom[twoDbinSamePhi][6] = twoDbinSamePhi + 2;
          neighbourCellsBottom[twoDbinSamePhi][7] = twoDbinLowerPhi + 2;
          neighbourCellsBottom[twoDbinSamePhi][8] = twoDbinHigherPhi + 2;
        }
        else if (z == 7)
        {
          nNeighbourCellsBottom[twoDbinSamePhi] = 9;
          neighbourCellsBottom[twoDbinSamePhi][6] = twoDbinSamePhi - 2;
          neighbourCellsBottom[twoDbinSamePhi][7] = twoDbinLowerPhi - 2;
          neighbourCellsBottom[twoDbinSamePhi][8] = twoDbinHigherPhi - 2;
        }
      }
    }
  }
}

buildConnectionMapsVertex()

void ITk::SiSpacePointsSeedMaker::buildConnectionMapsVertex ( std::array< int, arraySizePhiZV > & nNeighbourCells, std::array< std::array< int, arraySizeNeighbourBinsVertex >, arraySizePhiZV > & neighbourCells, int maxPhiBin )

staticprivate

Build maps for radius-azimuthal-Z sorted collections for Z Similar logic to the above, just simplified as only 3 regions in z exist!

For each azimuthal region loop through central Z regions

always include the two neighbour bins in phi

for the positive z bin, include the central z slice as well

for the negative z bin, include the central z slice as well

Definition at line 1088 of file ITkSiSpacePointsSeedMaker.cxx.

{
  for (int phiBin=0; phiBin<=maxPhiBin; ++phiBin) {
 
    int phiBinBelow = phiBin-1;
    if (phiBinBelow<0) phiBinBelow=maxPhiBin;
 
    int phiBinTop = phiBin+1;
    if (phiBinTop>maxPhiBin) phiBinTop=0;

    for (int zbin=0; zbin<arraySizeZV; ++zbin) {
 
      int twoDbinSamePhi  = phiBin*arraySizeZV+zbin;
      int twoDbinLowerPhi  = phiBinBelow*arraySizeZV+zbin;
      int twoDbinHigherPhi  = phiBinTop*arraySizeZV+zbin;

      nNeighbourCells[twoDbinSamePhi]   = 3;
      neighbourCells[twoDbinSamePhi][0] = twoDbinSamePhi;
      neighbourCells[twoDbinSamePhi][1] = twoDbinLowerPhi;
      neighbourCells[twoDbinSamePhi][2] = twoDbinHigherPhi;

      if (zbin>1) {
        nNeighbourCells[twoDbinSamePhi]   = 6;
        neighbourCells[twoDbinSamePhi][3] = twoDbinSamePhi-1;
        neighbourCells[twoDbinSamePhi][4] = twoDbinLowerPhi-1;
        neighbourCells[twoDbinSamePhi][5] = twoDbinHigherPhi-1;
      }
      else if (zbin<1) {
        nNeighbourCells[twoDbinSamePhi]   = 6;
        neighbourCells[twoDbinSamePhi][3] = twoDbinSamePhi+1;
        neighbourCells[twoDbinSamePhi][4] = twoDbinLowerPhi+1;
        neighbourCells[twoDbinSamePhi][5] = twoDbinHigherPhi+1;
      }
    }
  }
}

buildFrameWork()

void ITk::SiSpacePointsSeedMaker::buildFrameWork ( )

private

ensure consistency in the transverse IP cuts

symmetrise eta cut if eta min not explicitly set

set dz/dr cut values based on eta cuts

cache inverse pt cuts

set up the score thresholds based on the user-supplied properties The score of any seeds will always be >= the bonus applied, since the starting value is |d0|. Hence, by subtracting one, we get all seeds which have received an additional bonus in addition to the PPP/SSS one, which is the confirmation one by construction.

Build radius sorted containers

Now we construct the radius-azimuthal sorted containers. Binning is determined semi-dynamically based on the tool config

determine the phi binning

The max Nb. of bins possible is given by the binning enum

< for run-3: 200 : 6.28 ~ 31.8, bin size 0.0314

derive the optimum bin size in phi for our needs. We do this by checking the size needed for each of the passes we run, and then pick the larger one (more conservative). This is slightly less optimal than using separate settings per pass, but avoids having to book and store in memory two distinct R-phi-Z maps.

case 1: PPP seeds, if we use them

approximate lowest R location of pixel hits (driven by barrel)

approximate largest R location of pixel hits (driven by endcap)

case 2: SSS seeds, if we use them

this is the default phi binning as operated in release 21 - optimised for a trajectory with 400 MeV, from the origin, and Rmin = 0 / Rmax = 600mm float ptm = 400.;

if we cut below 400 MeV, adapt the ptm

truncate the bin size to fall within our thresholds

now we can determine the number of bins by dividing the interval by the bin size

additional protection against too many bins. Should not happen given constraints above

recompute inverse bin size, taking into account rounding + truncation

same logic as for the space points above

Definition at line 829 of file ITkSiSpacePointsSeedMaker.cxx.

{
  m_ptmin = std::abs(m_ptmin);
 
  if (m_ptmin < 100.)
    m_ptmin = 100.;

  if (m_maxdImpactSSS < m_maxdImpact)
    m_maxdImpactSSS = m_maxdImpact;

  if (std::abs(m_etamin) < .1)
    m_etamin = -m_etamax;
  m_dzdrmax0 = 1. / std::tan(2. * std::atan(std::exp(-m_etamax)));
  m_dzdrmin0 = 1. / std::tan(2. * std::atan(std::exp(-m_etamin)));

  m_ipt = 1. / std::abs(m_ptmin);
  m_ipt2 = m_ipt * m_ipt;

  m_seedScoreThresholdPPPConfirmationSeed = m_seedScoreBonusPPP - 1.;
  m_seedScoreThresholdSSSConfirmationSeed = m_seedScoreBonusSSS - 1.;

  m_nBinsR = static_cast<int>((m_r_rmax + .1) / m_binSizeR);


  constexpr float twoPi = 2. * M_PI;

  const int nPhiBinsMax = arraySizePhi;
  const float inverseSizePhiMax = static_cast<float>(nPhiBinsMax) / twoPi; 
  constexpr float inverseSizePhiMin = 10. / twoPi;

 
  if (m_optimisePhiBinning)
  {
    const float radiusPixelStart = m_fastTracking ? 50. : 40.; 
    const float radiusPixelEnd = m_fastTracking ? 250. : 320.; 
    const float binSizePhi_PPP = m_pixel ? azimuthalStep(m_ptmin, m_maxdImpact, radiusPixelStart, radiusPixelEnd) / 3.f : 1.f;
    const float binSizePhi_SSS = m_strip ? azimuthalStep(m_ptmin, m_maxdImpactSSS, m_rminSSS, m_rmaxSSS) / 3.f : 1.f;
    m_inverseBinSizePhiPPP = 1. / binSizePhi_PPP;
    m_inverseBinSizePhiSSS = 1. / binSizePhi_SSS;
  }
  else
  {
    float ptm = 400.;
    if (m_ptmin < ptm)
      ptm = m_ptmin;
    m_inverseBinSizePhiPPP = m_inverseBinSizePhiSSS = ptm / 60.;
  }

  if (m_inverseBinSizePhiPPP > inverseSizePhiMax)
    m_inverseBinSizePhiPPP = inverseSizePhiMax;
  else if (m_inverseBinSizePhiPPP < inverseSizePhiMin)
    m_inverseBinSizePhiPPP = inverseSizePhiMin;
  if (m_inverseBinSizePhiSSS > inverseSizePhiMax)
    m_inverseBinSizePhiSSS = inverseSizePhiMax;
  else if (m_inverseBinSizePhiSSS < inverseSizePhiMin)
    m_inverseBinSizePhiSSS = inverseSizePhiMin;

  m_maxPhiBinPPP = static_cast<int>(twoPi * m_inverseBinSizePhiPPP);
  if (m_maxPhiBinPPP >= nPhiBinsMax) m_maxPhiBinPPP = nPhiBinsMax - 1;
  m_maxPhiBinSSS = static_cast<int>(twoPi * m_inverseBinSizePhiSSS);
  if (m_maxPhiBinSSS >= nPhiBinsMax) m_maxPhiBinSSS = nPhiBinsMax - 1;
  m_inverseBinSizePhiPPP = ( m_maxPhiBinPPP + 1 ) / twoPi;
  m_inverseBinSizePhiSSS = ( m_maxPhiBinSSS + 1 ) / twoPi;
 
  // Build radius-azimuthal-Z sorted containers for Z-vertices
  const int   nPhiBinsVertexMax  = arraySizePhiV;
  const float inverseBinSizePhiVertexMax = static_cast<float>(nPhiBinsVertexMax)/twoPi;
  m_inverseBinSizePhiVertex = m_ptmin/120.f;
  if (m_inverseBinSizePhiVertex > inverseBinSizePhiVertexMax) m_inverseBinSizePhiVertex = inverseBinSizePhiVertexMax;
  m_maxBinPhiVertex = static_cast<int>(twoPi*m_inverseBinSizePhiVertex);
  if (m_maxBinPhiVertex>=nPhiBinsVertexMax) m_maxBinPhiVertex = nPhiBinsVertexMax-1;
 
  buildConnectionMaps(m_nNeighbourCellsBottomPPP, m_nNeighbourCellsTopPPP,
                      m_neighbourCellsBottomPPP, m_neighbourCellsTopPPP,
                      m_maxPhiBinPPP, false);
 
  buildConnectionMaps(m_nNeighbourCellsBottomSSS, m_nNeighbourCellsTopSSS,
                      m_neighbourCellsBottomSSS, m_neighbourCellsTopSSS,
                      m_maxPhiBinSSS, true);
 
  buildConnectionMapsVertex(m_nNeighboursVertexPhiZ,
                m_neighboursVertexPhiZ,
                m_maxBinPhiVertex);
 
}

convertToBeamFrameWork()

void ITk::SiSpacePointsSeedMaker::convertToBeamFrameWork ( EventData & data, const Trk::SpacePoint * , float *  )

staticprivate

Definition at line 1192 of file ITkSiSpacePointsSeedMaker.cxx.

{
  r[0] = static_cast<float>(sp->globalPosition().x()) - data.xbeam[0];
  r[1] = static_cast<float>(sp->globalPosition().y()) - data.ybeam[0];
  r[2] = static_cast<float>(sp->globalPosition().z()) - data.zbeam[0];
}

dump()

MsgStream & ITk::SiSpacePointsSeedMaker::dump ( EventData & data, MsgStream & out ) const

overridevirtual

Definition at line 615 of file ITkSiSpacePointsSeedMaker.cxx.

{
  if (data.nprint)
    return dumpEvent(data, out);
  return dumpConditions(data, out);
}

dumpConditions()

MsgStream & ITk::SiSpacePointsSeedMaker::dumpConditions ( EventData & data, MsgStream & out ) const

private

Definition at line 626 of file ITkSiSpacePointsSeedMaker.cxx.

{
  int n = 42-m_spacepointsPixel.key().size();
  std::string s2;
  for (int i=0; i<n; ++i) s2.append(" ");
  s2.append("|");
  n     = 42-m_spacepointsStrip.key().size();
  std::string s3;
  for (int i=0; i<n; ++i) s3.append(" ");
  s3.append("|");
  n     = 42-m_spacepointsOverlap.key().size();
  std::string s4;
  for (int i=0; i<n; ++i) s4.append(" ");
  s4.append("|");
  n     = 42-m_beamSpotKey.key().size();
  std::string s5;
  for (int i=0; i<n; ++i) s5.append(" ");
  s5.append("|");
 
  out<<"|---------------------------------------------------------------------|"
     <<endmsg;
  out<<"| Pixel    space points   | "<<m_spacepointsPixel.key() <<s2
     <<endmsg;
  out<<"| Strip    space points   | "<<m_spacepointsStrip.key()<<s3
     <<endmsg;
  out<<"| Overlap  space points   | "<<m_spacepointsOverlap.key()<<s4
     <<endmsg;
  out<<"| BeamConditionsService   | "<<m_beamSpotKey.key()<<s5
     <<endmsg;
  out<<"| usePixel                | "
     <<std::setw(12)<<m_pixel 
     <<"                              |"<<endmsg;
  out<<"| useStrip                  | "
     <<std::setw(12)<<m_strip
     <<"                              |"<<endmsg;
  out<<"| maxSize                 | "
     <<std::setw(12)<<m_maxsize 
     <<"                              |"<<endmsg;
  out<<"| maxSizeSP               | "
     <<std::setw(12)<<m_maxsizeSP
     <<"                              |"<<endmsg;
  out<<"| pTmin  (mev)            | "
     <<std::setw(12)<<std::setprecision(5)<<m_ptmin
     <<"                              |"<<endmsg;
  out<<"| max radius SP           | "
     <<std::setw(12)<<std::setprecision(5)<<m_r_rmax 
     <<"                              |"<<endmsg;
  out<<"| radius step             | "
     <<std::setw(12)<<std::setprecision(5)<<m_binSizeR
     <<"                              |"<<endmsg;
  out<<"| min Z-vertex position   | "
     <<std::setw(12)<<std::setprecision(5)<<m_zmin
     <<"                              |"<<endmsg;
  out<<"| max Z-vertex position   | "
     <<std::setw(12)<<std::setprecision(5)<<m_zmax
     <<"                              |"<<endmsg;
  out<<"| min space points dR SSS | "
     <<std::setw(12)<<std::setprecision(5)<<m_drminSSS
     <<"                              |"<<std::endl;
  out<<"| max space points dR SSS | "
     <<std::setw(12)<<std::setprecision(5)<<m_drmaxSSS
     <<"                              |"<<std::endl;
  out<<"| min space points dR PPP | "
     <<std::setw(12)<<std::setprecision(5)<<m_drminPPP
     <<"                              |"<<std::endl;
  out<<"| max space points dR PPP | "
     <<std::setw(12)<<std::setprecision(5)<<m_drmaxPPP
     <<"                              |"<<std::endl;
  out<<"| max dZ    impact        | "
     <<std::setw(12)<<std::setprecision(5)<<m_dzver 
     <<"                              |"<<endmsg;
  out<<"| max dZ/dR impact        | "
     <<std::setw(12)<<std::setprecision(5)<<m_dzdrver 
     <<"                              |"<<endmsg;
  out<<"| max       impact        | "
     <<std::setw(12)<<std::setprecision(5)<<m_maxdImpact
     <<"                              |"<<endmsg;
  out<<"| max       impact sss    | "
     <<std::setw(12)<<std::setprecision(5)<<m_maxdImpactSSS
     <<"                              |"<<endmsg;
  out<<"|---------------------------------------------------------------------|"
     <<endmsg;
  out<<"| Beam X center           | "
     <<std::setw(12)<<std::setprecision(5)<<data.xbeam[0]
     <<"                              |"<<endmsg;
  out<<"| Beam Y center           | "
     <<std::setw(12)<<std::setprecision(5)<<data.ybeam[0]
     <<"                              |"<<endmsg;
  out<<"| Beam Z center           | "
     <<std::setw(12)<<std::setprecision(5)<<data.zbeam[0]
     <<"                              |"<<endmsg;
  out<<"| Beam X-axis direction   | "
     <<std::setw(12)<<std::setprecision(5)<<data.xbeam[1]
     <<std::setw(12)<<std::setprecision(5)<<data.xbeam[2]
     <<std::setw(12)<<std::setprecision(5)<<data.xbeam[3]
     <<"      |"<<endmsg;
  out<<"| Beam Y-axis direction   | "
     <<std::setw(12)<<std::setprecision(5)<<data.ybeam[1]
     <<std::setw(12)<<std::setprecision(5)<<data.ybeam[2]
     <<std::setw(12)<<std::setprecision(5)<<data.ybeam[3]
     <<"      |"<<endmsg;
  out<<"| Beam Z-axis direction   | "
     <<std::setw(12)<<std::setprecision(5)<<data.zbeam[1]
     <<std::setw(12)<<std::setprecision(5)<<data.zbeam[2]
     <<std::setw(12)<<std::setprecision(5)<<data.zbeam[3]
     <<"      |"<<endmsg;
  out<<"|---------------------------------------------------------------------|"
     <<endmsg;
  return out;
 
 
}

dumpEvent()

MsgStream & ITk::SiSpacePointsSeedMaker::dumpEvent ( EventData & data, MsgStream & out )

staticprivate

Definition at line 743 of file ITkSiSpacePointsSeedMaker.cxx.

{
  out<<"|---------------------------------------------------------------------|"
     <<endmsg;
  out<<"| ns                    | "
     <<std::setw(12)<<data.ns
     <<"                              |"<<endmsg;
  out<<"| nsaz                  | "
     <<std::setw(12)<<data.nsaz
     <<"                              |"<<endmsg;
  out<<"| nsazv                 | "
     <<std::setw(12)<<data.nsazv
     <<"                              |"<<endmsg;
  out<<"| seeds                   | "
     <<std::setw(12)<<data.i_ITkSeeds.size()
     <<"                              |"<<endmsg;
  out<<"|---------------------------------------------------------------------|"
     <<endmsg;
  return out;
 
}

erase()

void ITk::SiSpacePointsSeedMaker::erase ( EventData & data )

staticprivate

Definition at line 1410 of file ITkSiSpacePointsSeedMaker.cxx.

{
  for (int i = 0; i < data.nrfz; ++i)
  {
    int n = data.rfz_index[i];
    data.rfz_map[n] = 0;
    data.rfz_ITkSorted[n].clear();
  }
 
  for (int i = 0; i < data.nrfzv; ++i)
  {
    int n = data.rfzv_index[i];
    data.rfzv_map[n] = 0;
    data.rfzv_ITkSorted[n].clear();
  }
 
  for (int i = 0; i < data.nr; ++i) {
    int n = data.r_index[i];
    data.r_map[n] = 0;
    data.r_ITkSorted[n].clear();
  }
 
  data.state = 0;
  data.nsaz = 0;
  data.nsazv = 0;
  data.nrfz = 0;
  data.nrfzv = 0;
  data.ns = 0;
  data.nr = 0;
}

fillLists()

void ITk::SiSpacePointsSeedMaker::fillLists ( EventData & data ) const

private

The following is done separately for each iteration. We sort the hits in our radially sorted lists into the z-phi binning, keeping only those we want to consider to reduce combinatorics

Note that the use of r_first to start the loop is what ensures that the first iteration is a pure SSS pass. In newEvent, r_first is set to the bin after the last radial bin containing Pixel space points. For the second iteration, we reset it to zero and thus start in the pixels.

< if we encounter Si hits at z > +100m, we are probably not in ATLAS anymore...

skip empty radial bins

remember the first non-empty bin we encounter

Azimuthal angle sort find the bin by dividing phi in 0...2pi by the bin size

handle overflows

z-coordinate sort. Here, we have a variable bin size. Use a map to replace 5 levels of nested ternaries for a somewhat more readable notation while retaining a logN lookup speed

some protection in case things go REALLY wrong

< z beyond the max: return last bin

2D bin index - computed from the 1D using standard 2D array bin arithmetics

increment total counter of space points. This is not reset between iterations.

the conditional seems to always be true. The rfz_index vector stores the 2D bin for each SP in the radius-sorted map. This way, we obtain effectively a 3D binning in r(via the r-sorted vector), phi and z (via the 2D index)

Definition at line 1203 of file ITkSiSpacePointsSeedMaker.cxx.

{
  constexpr float twoPi = 2. * M_PI;
 
  int firstRadialBin = 0;
  int lastRadialBin = 0;
  bool endcap = false;

 
  const std::map<float, int> ztoBin{
      {-2500., 0},
      {-1400., 1},
      {-925., 2},
      {-500., 3},
      {-250., 4},
      {250., 5},
      {500., 6},
      {925., 7},
      {1400, 8},
      {2500, 9},
      {100000, 10}, 
  };
 
  bool isPixel = (m_fastTracking && m_pixel) || data.iteration == 1;
 
  int nPhiBins = isPixel ? m_maxPhiBinPPP : m_maxPhiBinSSS;
  float inverseBinSizePhi = isPixel ? m_inverseBinSizePhiPPP : m_inverseBinSizePhiSSS;
 
  for (int radialBin = data.r_first; radialBin < m_nBinsR; ++radialBin)
  {
    if (!data.r_map[radialBin])
      continue;
 
    // Stop when we reach strip SP in PPP iteration #1
    std::vector<SiSpacePointForSeed *>::iterator SP_first = data.r_ITkSorted[radialBin].begin();
    if (isPixel && (*SP_first)->spacepoint->clusterList().second)
      break;

    if (firstRadialBin == 0)
      firstRadialBin = radialBin;
    lastRadialBin = radialBin;
 
    // loop over the space points in the r-bin and sort them into the 2d phi-z binning
    for (SiSpacePointForSeed *SP : data.r_ITkSorted[radialBin])
    {

      float Phi = SP->phi();
      if (Phi < 0.)
        Phi += twoPi; // phi is defined in [0..2pi] for the binning
      int phiBin = static_cast<int>(Phi * inverseBinSizePhi);
      if (phiBin < 0)
      {
        phiBin = nPhiBins;
      }
      else if (phiBin > nPhiBins)
      {
        phiBin = 0;
      }
 
      float Z = SP->z();
      endcap = (std::abs(Z) > 1490);
      int zBin{0};
      auto bound = ztoBin.lower_bound(Z);
      if (bound == ztoBin.end())
      {
        --bound; 
      }
      zBin = bound->second;

      int twoDbin = phiBin * arraySizeZ + zBin;
      ++data.nsaz;
      // push our space point into the 2D binned array
      data.rfz_ITkSorted[twoDbin].push_back(SP);

      if (!data.rfz_map[twoDbin]++)
        data.rfz_index[data.nrfz++] = twoDbin;
    }
  }
 
  data.state = 0;
 
  if (m_fastTracking) {
    // Loop through all RZ collections and sort them in radius order
    //
    for (int twoDbin(0); twoDbin != arraySizePhiZ; ++twoDbin) {
      if (data.rfz_ITkSorted[twoDbin].size() > 1) {
        std::sort(data.rfz_ITkSorted[twoDbin].begin(), data.rfz_ITkSorted[twoDbin].end(), SiSpacePointsComparison_R());
      }
    }
 
    if (m_strip) {
      data.RTmin = m_rminSSS ;
      data.RTmax = m_rmaxSSS ;
    }
 
  } else {
    if (isPixel) { // PPP
      data.RTmin = m_binSizeR*firstRadialBin+10. ;
      data.RTmax = m_binSizeR*lastRadialBin-10.;
    } else { //SSS
      if (endcap and m_isLRT) {
        data.RTmin = m_binSizeR*firstRadialBin+10. ;
        data.RTmax = m_binSizeR*lastRadialBin-10.;
      } else {
        data.RTmin = m_binSizeR*firstRadialBin+30. ;
        data.RTmax = m_binSizeR*lastRadialBin-150.;
      }
    }
  }
 
}

fillSeeds()

void ITk::SiSpacePointsSeedMaker::fillSeeds ( EventData & data )

staticprivate

no seeds - nothing to do.

loop over the seed candidates we have stored in the event data

quality score of the seed, lower = better, list is sorted by quality

this will set the quality member of all points on the seed to the quality score of this candidate

if we have space, write the seed directly into an existing slot

otherwise, extend the seed list and update the iterators

Definition at line 2749 of file ITkSiSpacePointsSeedMaker.cxx.

{
  data.fillOneSeeds = 0;
 
  std::multimap<float, SiSpacePointsProSeed *>::iterator it_seedCandidate = data.ITkMapOneSeeds.begin();
  std::multimap<float, SiSpacePointsProSeed *>::iterator it_endSeedCandidates = data.ITkMapOneSeeds.end();
 
  if (data.nOneSeedsQ){
    it_seedCandidate  = data.ITkMapOneSeedsQ.begin();
    it_endSeedCandidates = data.ITkMapOneSeedsQ.end();
  }

  if (it_seedCandidate == it_endSeedCandidates)
    return;
 
  SiSpacePointsProSeed *theSeed{nullptr};

  for (; it_seedCandidate != it_endSeedCandidates; ++it_seedCandidate)
  {

    float quality = (*it_seedCandidate).first;
    theSeed = (*it_seedCandidate).second;

    if (!theSeed->setQuality(quality))
      continue;

    if (data.i_ITkSeedEnd != data.i_ITkSeeds.end())
    {
      theSeed = &(*data.i_ITkSeedEnd++);
      *theSeed = *(*it_seedCandidate).second;
    }
    else
    {
      data.i_ITkSeeds.emplace_back(*(*it_seedCandidate).second);
      //unused value, keep in comment to avoid repeating in future
      //theSeed = &(data.i_ITkSeeds.back()); 
      data.i_ITkSeedEnd = data.i_ITkSeeds.end();
    }
 
    ++data.fillOneSeeds;
  } 
}

finalize()

StatusCode ITk::SiSpacePointsSeedMaker::finalize ( )

overridevirtual

Definition at line 130 of file ITkSiSpacePointsSeedMaker.cxx.

{
  return AlgTool::finalize();
}

find2Sp()

void ITk::SiSpacePointsSeedMaker::find2Sp ( EventData & data, const std::list< Trk::Vertex > & lv ) const

overridevirtual

with two space points with or without vertex constraint

Definition at line 454 of file ITkSiSpacePointsSeedMaker.cxx.

{
  ATH_MSG_WARNING("ITk::SiSpacePointsSeedMaker::find2Sp not implemented!");
}

find3Sp() [1/2]

void ITk::SiSpacePointsSeedMaker::find3Sp ( const EventContext & ctx, EventData & data, const std::list< Trk::Vertex > & lv ) const

overridevirtual

with three space points with or without vertex constraint

call fillLists to repopulate the candidate space points

reset the Z interval stored in the data object

mode 2 if we have no vertices in the list, otherwise mode 3

copy the vertices into the data object, if we have any. Note that by construction, newv will ALWAYS be false, also if we pass vertices.

update the data object's config

< This performs the actual seed finding

reset the i_ITkSeed iterator - this is used to return the seeds to the consumer when they call next()

Definition at line 464 of file ITkSiSpacePointsSeedMaker.cxx.

{
  if (not data.initialized)
    initializeEventData(data, ctx);

  fillLists(data);

  data.zminU = m_zmin;
  data.zmaxU = m_zmax;
  int mode = 2;
  if (lv.begin() != lv.end())
    mode = 3;
  bool newv = newVertices(data, lv);
  if (newv || !data.state || data.nspoint != 3 || data.mode != mode || data.nlist)
  {
    data.i_ITkSeedEnd = data.i_ITkSeeds.begin();
    data.state = 1;
    data.nspoint = 3;
    data.nlist = 0;
    data.mode = mode;
    data.endlist = true;
    data.fvNmin = 0;
    data.fNmin = 0;
    data.zMin = 0;
    production3Sp(data); 
  }

  data.i_ITkSeed = data.i_ITkSeeds.begin();
 
  if (msgLvl(MSG::DEBUG))
  {
    data.nprint = 1;
    dump(data, msg(MSG::DEBUG));
  }
}

find3Sp() [2/2]

void ITk::SiSpacePointsSeedMaker::find3Sp ( const EventContext & ctx, EventData & data, const std::list< Trk::Vertex > & lv, const double * zVertex ) const

overridevirtual

with three space points with or without vertex constraint with information about min and max Z of the vertex

call fillLists to repopulate the candidate space points

Update the data object's Z interval based on the interval passed as arg to this function.

< don't go beyond user-specified intervals

< don't go beyond user-specified intervals

mode 2 when working with the Z constraint

copy the vertices into the data object, if we have any. Note that by construction, newv will ALWAYS be false, also if we pass vertices.

update the data object's config

< This performs the actual seed finding

reset the i_ITkSeed iterator - this is used to return the seeds to the consumer when they call next()

Definition at line 515 of file ITkSiSpacePointsSeedMaker.cxx.

{
  if (not data.initialized)
    initializeEventData(data, ctx);

  fillLists(data);

  data.zminU = ZVertex[0];
  if (data.zminU < m_zmin)
    data.zminU = m_zmin; 
  data.zmaxU = ZVertex[1];
  if (data.zmaxU > m_zmax)
    data.zmaxU = m_zmax; 

  int mode = 2;
  if (lv.begin() != lv.end())
    mode = 3;
  bool newv = newVertices(data, lv);
  if (newv || !data.state || data.nspoint != 3 || data.mode != mode || data.nlist)
  {
    data.i_ITkSeedEnd = data.i_ITkSeeds.begin();
    data.state = 1;
    data.nspoint = 3;
    data.nlist = 0;
    data.mode = mode;
    data.endlist = true;
    data.fvNmin = 0;
    data.fNmin = 0;
    data.zMin = 0;
    production3Sp(data); 
  }
  data.i_ITkSeed = data.i_ITkSeeds.begin();
 
  if (msgLvl(MSG::DEBUG))
  {
    data.nprint = 1;
    dump(data, msg(MSG::DEBUG));
  }
}

findNext()

void ITk::SiSpacePointsSeedMaker::findNext ( EventData & data ) const

private

Definition at line 769 of file ITkSiSpacePointsSeedMaker.cxx.

{
  if (data.endlist)
    return;
 
  data.i_ITkSeedEnd = data.i_ITkSeeds.begin();
 
  if (data.mode == 2 || data.mode == 3 || data.mode == 5 || data.mode == 6)
    production3Sp(data);
 
  data.i_ITkSeed = data.i_ITkSeeds.begin();
  ++data.nlist;
}

findVSp()

void ITk::SiSpacePointsSeedMaker::findVSp ( const EventContext & ctx, EventData & data, const std::list< Trk::Vertex > & lv ) const

overridevirtual

with variable number space points with or without vertex constraint Variable means (2,3,4,....) any number space points

call fillLists to repopulate the candidate space points

Definition at line 572 of file ITkSiSpacePointsSeedMaker.cxx.

{
 
  if (not data.initialized)
    initializeEventData(data, ctx);

  fillLists(data);
 
  data.zminU = m_zmin;
  data.zmaxU = m_zmax;
 
  int mode = 5;
  if (lv.begin() != lv.end())
    mode = 6;
  bool newv = newVertices(data, lv);
 
  if (newv || !data.state || data.nspoint != 4 || data.mode != mode || data.nlist)
  {
    data.i_ITkSeedEnd = data.i_ITkSeeds.begin();
    data.state = 1;
    data.nspoint = 4;
    data.nlist = 0;
    data.mode = mode;
    data.endlist = true;
    data.fvNmin = 0;
    data.fNmin = 0;
    data.zMin = 0;
    production3Sp(data);
  }
  data.i_ITkSeed = data.i_ITkSeeds.begin();
 
  if (msgLvl(MSG::DEBUG))
  {
    data.nprint = 1;
    dump(data, msg(MSG::DEBUG));
  }
}

getWriteNtupleBoolProperty()

bool ITk::SiSpacePointsSeedMaker::getWriteNtupleBoolProperty ( ) const

overridevirtual

Definition at line 3420 of file ITkSiSpacePointsSeedMaker.cxx.

{
  return m_writeNtuple;
}

initialize()

StatusCode ITk::SiSpacePointsSeedMaker::initialize ( )

overridevirtual

Definition at line 55 of file ITkSiSpacePointsSeedMaker.cxx.

{
  StatusCode sc = AlgTool::initialize();
 
  ATH_CHECK(m_spacepointsPixel.initialize(m_pixel));
  ATH_CHECK(m_spacepointsStrip.initialize(m_strip));
  ATH_CHECK(m_spacepointsOverlap.initialize(m_useOverlap));
 
  // Get beam geometry
  //
  ATH_CHECK(m_beamSpotKey.initialize());
 
  ATH_CHECK(m_fieldCondObjInputKey.initialize());
 
  // PRD-to-track association (optional)
  ATH_CHECK(m_prdToTrackMap.initialize(!m_prdToTrackMap.key().empty()));
 
  // Build framework
  //
  buildFrameWork();
 
  // Get output print level
  //
  m_outputlevel = msg().level() - MSG::DEBUG;
 
  m_umax = 100. - std::abs(m_umax) * 300.;
 
  if (m_writeNtuple) {
    //coverity[MISSING_LOCK]
    ATH_CHECK( m_thistSvc.retrieve() );
 
    m_treeName = (std::string("SeedTree_")+name());
    std::replace( m_treeName.begin(), m_treeName.end(), '.', '_' );
 
    m_outputTree = new TTree( m_treeName.c_str() , "SeedMakerValTool");
 
    m_outputTree->Branch("eventNumber",    &m_eventNumber,"eventNumber/L");
    m_outputTree->Branch("d0",             &m_d0);
    m_outputTree->Branch("z0",             &m_z0);
    m_outputTree->Branch("pt",             &m_pt);
    m_outputTree->Branch("eta",            &m_eta);
    m_outputTree->Branch("x1",             &m_x1);
    m_outputTree->Branch("x2",             &m_x2);
    m_outputTree->Branch("x3",             &m_x3);
    m_outputTree->Branch("y1",             &m_y1);
    m_outputTree->Branch("y2",             &m_y2);
    m_outputTree->Branch("y3",             &m_y3);
    m_outputTree->Branch("z1",             &m_z1);
    m_outputTree->Branch("z2",             &m_z2);
    m_outputTree->Branch("z3",             &m_z3);
    m_outputTree->Branch("r1",             &m_r1);
    m_outputTree->Branch("r2",             &m_r2);
    m_outputTree->Branch("r3",             &m_r3);
    m_outputTree->Branch("quality",        &m_quality);
    m_outputTree->Branch("seedType",       &m_type);
    m_outputTree->Branch("givesTrack",     &m_givesTrack);
    m_outputTree->Branch("dzdr_b",         &m_dzdr_b);
    m_outputTree->Branch("dzdr_t",         &m_dzdr_t);
    m_outputTree->Branch("track_pt",       &m_trackPt);
    m_outputTree->Branch("track_eta",      &m_trackEta);
 
    std::string fullTreeName = m_treeFolder + m_treeName;
 
    ATH_CHECK(  m_thistSvc->regTree( fullTreeName, m_outputTree )  );
 
  }
 
 
  return sc;
}

initializeEventData()

void ITk::SiSpacePointsSeedMaker::initializeEventData ( EventData & data, const EventContext & ctx ) const

private

maxsize not used

sizeRF not used

Read the field information

retrieve field

Knowing the field (note that the field cache returns the field in units of kiloTesla!) allows to set the circle-radius to pT conversion factor.

See for example ATLAS-CONF-2010-072 R[mm] =pT[GeV] / (3·10−4×B[T]) = pT[MeV] / (300 *Bz[kT])

We actually estimate the circle diameter, 2R, in the seeding. So what we want is: 2R = pT[MeV] x 2 / (300 x Bz) = K x pT[MeV].

helper variables allowing us to directly apply our pt cut on the variables available at seed level. ipt2K is 1 / (K * 0.9 * pt cut)²

related to the mysterious magic number, m_COF{134*.05*9}

save magnetic field used for later

Definition at line 2954 of file ITkSiSpacePointsSeedMaker.cxx.

{
  int seedArrayPerSPSize = (m_maxOneSizePPP > m_maxOneSizeSSS ? m_maxOneSizePPP : m_maxOneSizeSSS);
  if (m_alwaysKeepConfirmedStripSeeds || m_alwaysKeepConfirmedPixelSeeds)
    seedArrayPerSPSize = 50;
  data.initialize(EventData::ToolType::ITk,
                  m_maxsizeSP,
                  seedArrayPerSPSize,
                  0, 
                  m_nBinsR,
                  0, 
                  arraySizePhiZ,
                  arraySizePhiZV,
                  m_checketa);
 
  buildBeamFrameWork(data);

  double magField[3]{0, 0, 0};
  double globalPos[3] = {10., 10., 0.};
 
  MagField::AtlasFieldCache fieldCache;
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
  const AtlasFieldCacheCondObj *fieldCondObj{*readHandle};
  if (fieldCondObj == nullptr) {
    ATH_MSG_ERROR("ITk::SiSpacePointsSeedMaker: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
    return;
  }
 
  fieldCondObj->getInitializedCache(fieldCache);
 
  if (fieldCache.solenoidOn()) {
    fieldCache.getFieldZR(globalPos, magField);
    data.K = 2. / (300. * magField[2]);
  } else {
    data.K = 2. / (300. * 5.);
  }

  data.ipt2K = m_ipt2 / (data.K * data.K);
  data.ipt2C = m_ipt2 * m_COF;
  data.COFK = m_COF * (data.K * data.K);
  data.bField[0] = magField[0];
  data.bField[1] = magField[1];
  data.bField[2] = magField[2];
 
}

isConfirmedSeed()

bool ITk::SiSpacePointsSeedMaker::isConfirmedSeed ( const SiSpacePointForSeed * bottomSP, const SiSpacePointForSeed * topSP, float quality ) const

private

Helper method to determine if a seed is 'confirmed' - this means that a second seed exists with compatible curvature, the same bottom and central SP, but a different third SP.

This information is stored in a modification of the seed quality, which we check here.

Parameters

[in]	bottomSP	bottom space point
[in]	topSP	top space point
[in]	quality	seed quality

Returns

true if the seed is confirmed, false otherwise

SSS seeds

PPP seeds

PPS: the confirmation is the only quality modifier applied

Definition at line 3358 of file ITkSiSpacePointsSeedMaker.cxx.

{

  if (bottomSP->spacepoint->clusterList().second)
  {
    return (quality < m_seedScoreThresholdSSSConfirmationSeed);
  }
  else if (!topSP->spacepoint->clusterList().second)
  {
    return (quality < m_seedScoreThresholdPPPConfirmationSeed);
  }
  else
    return (quality < 0.);
}

isUsed()

bool ITk::SiSpacePointsSeedMaker::isUsed ( const Trk::SpacePoint * sp, const Trk::PRDtoTrackMap & prd_to_track_map ) const

inlineprivate

Definition at line 519 of file ITkSiSpacePointsSeedMaker.h.

  {
    const Trk::PrepRawData* d = sp->clusterList().first;
    if (!d || !prd_to_track_map.isUsed(*d)) return false;
 
    d = sp->clusterList().second;
    if (!d || prd_to_track_map.isUsed(*d)) return true;
 
    return false;
  }

isZCompatible()

bool ITk::SiSpacePointsSeedMaker::isZCompatible ( EventData & data, float Zv, float R, float T ) const

private

Definition at line 2843 of file ITkSiSpacePointsSeedMaker.cxx.

{
  if (Zv < data.zminU || Zv > data.zmaxU)
    return false;
  if (!data.isvertex)
    return true;
 
  float dZmin = std::numeric_limits<float>::max();
  for (const float &v : data.l_vertex)
  {
    float dZ = std::abs(v - Zv);
    if (dZ >= dZmin)
      break;
    dZmin = dZ;
  }
  return dZmin < (m_dzver + m_dzdrver * R) * sqrt(1. + T * T);
}

newEvent()

void ITk::SiSpacePointsSeedMaker::newEvent ( const EventContext & ctx, EventData & data, int iteration ) const

overridevirtual

if not done so, book the arrays etc inside the event data object

Erase any existing entries in the data object

pass the iteration info into our data object

< max score, where low scores are "better".

build the r-binning.

set the spacepoint iterator to the beginning of the space-point list

as for the pixel, veto already used SP if we are using the PRD to track map in laterpasses of track finding. Also, veto SP outside the maximum and minimum radii

create a space point and write it into the data object's list of points

Determine the radial bin

again store the SP in the r-binned vectors

update the count of SP in the given bin

update the r_index map and data.nr if needed

and increment the SP count too.

Get strip overlap space points containers from store gate

usual rejection of SP used in previous track finding passes if we run with the PRT to track map + check of the max and min radii

SP creation, entry into list of the data object

radial bin determination

insert into the "histogram" vector

update the counter for each bin content

update the bin index list and occupied bin counter

and the total SP count too.

loop over the pixel space points

if we use the PRD to track map and this SP has already been used in a track, bail out also skip any SP outside the r binning

create a SiSpacePointForSeed from the space point. This will also add the point to the l_spforseed list and update the i_spforseed iterator

this can occur if we fail the eta cut

determine the r-bin of this SP. done by dividing the radius by the bin size.

catch outliers

now add the SP to the r-binned vector

increment the counter for this bin

if this is the first time we see this bin in use, we update the index map for this bin to the radius bin index

update the space point counter

Definition at line 139 of file ITkSiSpacePointsSeedMaker.cxx.

{
  if (!m_pixel && !m_strip)
    return;

  if (not data.initialized)
    initializeEventData(data, ctx);

  erase(data);
  data.trigger = false;
  data.iteration = iteration;
  if (iteration <= 0)
    data.iteration = 0;
  data.dzdrmin = m_dzdrmin0;
  data.checketa = data.dzdrmin > 1.;
  data.dzdrmax = m_dzdrmax0;
  data.maxScore = m_maxScore; 
  data.r_first = 0;

  float oneOverBinSizeR = 1. / m_binSizeR;
  int maxBinR = m_nBinsR - 1;

  data.i_ITkSpacePointForSeed = data.l_ITkSpacePointForSeed.begin();
 
  bool isPixel = (m_fastTracking && m_pixel) || data.iteration == 1;
 
  if (not isPixel)
  {
    // Now, we will populate the space point list in the event data object.
 
    // Set the seed multiplicity strategy of the event data to the one configured
    // by the user for strip seeds
    data.maxSeedsPerSP = m_maxOneSizeSSS;
    data.keepAllConfirmedSeeds = m_alwaysKeepConfirmedStripSeeds;
 
    SG::ReadHandle<Trk::PRDtoTrackMap> prd_to_track_map;
    const Trk::PRDtoTrackMap *prd_to_track_map_cptr = nullptr;
    if (!m_prdToTrackMap.key().empty()) {
      prd_to_track_map = SG::ReadHandle<Trk::PRDtoTrackMap>(m_prdToTrackMap, ctx);
      if (!prd_to_track_map.isValid()) {
        ATH_MSG_ERROR("Failed to read PRD to track association map: " << m_prdToTrackMap.key());
      }
      prd_to_track_map_cptr = prd_to_track_map.cptr();
    }
 
    SG::ReadHandle<SpacePointContainer> spacepointsStrip{m_spacepointsStrip, ctx};
    if (spacepointsStrip.isValid()) {
      for (const SpacePointCollection *spc : *spacepointsStrip) {
        for (const Trk::SpacePoint *sp : *spc) {
          if ((prd_to_track_map_cptr && isUsed(sp, *prd_to_track_map_cptr)) || sp->r() > m_r_rmax || sp->r() < m_r_rmin)
            continue;
          SiSpacePointForSeed *sps = newSpacePoint(data, sp);
          if (!sps)
            continue;

          int radiusBin = static_cast<int>(sps->radius() * oneOverBinSizeR);
          if (radiusBin > maxBinR)
            radiusBin = maxBinR;
          data.r_ITkSorted[radiusBin].push_back(sps);
          ++data.r_map[radiusBin];
          if (data.r_map[radiusBin] == 1)
            data.r_index[data.nr++] = radiusBin;
          ++data.ns;
        }
      }
    }
    if (m_useOverlap && !data.checketa) {
      SG::ReadHandle<SpacePointOverlapCollection> spacepointsOverlap{m_spacepointsOverlap, ctx};
      if (spacepointsOverlap.isValid()) {
        for (const Trk::SpacePoint *sp : *spacepointsOverlap) {
          if ((prd_to_track_map_cptr && isUsed(sp, *prd_to_track_map_cptr)) || sp->r() > m_r_rmax || sp->r() < m_r_rmin)
            continue;

          SiSpacePointForSeed *sps = newSpacePoint(data, sp);
          if (!sps)
            continue;

          int radiusBin = static_cast<int>(sps->radius() * oneOverBinSizeR);
          if (radiusBin > maxBinR)
            radiusBin = maxBinR;
          data.r_ITkSorted[radiusBin].push_back(sps);
          ++data.r_map[radiusBin];
          if (data.r_map[radiusBin] == 1)
            data.r_index[data.nr++] = radiusBin;
          ++data.ns;
        }
      }
    }
  } else {
 
    // Now, we will populate the space point list in the event data object.
 
    // Set the seed multiplicity strategy of the event data to the one configured
    // by the user for pixel seeds
    data.maxSeedsPerSP = m_maxOneSizePPP;
    data.keepAllConfirmedSeeds = m_alwaysKeepConfirmedPixelSeeds;
 
    SG::ReadHandle<Trk::PRDtoTrackMap> prd_to_track_map;
    const Trk::PRDtoTrackMap *prd_to_track_map_cptr = nullptr;
    if (!m_prdToTrackMap.key().empty()) {
      prd_to_track_map = SG::ReadHandle<Trk::PRDtoTrackMap>(m_prdToTrackMap, ctx);
      if (!prd_to_track_map.isValid()) {
        ATH_MSG_ERROR("Failed to read PRD to track association map: " << m_prdToTrackMap.key());
      }
      prd_to_track_map_cptr = prd_to_track_map.cptr();
    }
 
    SG::ReadHandle<SpacePointContainer> spacepointsPixel{m_spacepointsPixel, ctx};
    if (spacepointsPixel.isValid()) {
      for (const SpacePointCollection *spc : *spacepointsPixel) {
        for (const Trk::SpacePoint *sp : *spc) {
          if ((prd_to_track_map_cptr && isUsed(sp, *prd_to_track_map_cptr)) || sp->r() > m_r_rmax || sp->r() < m_r_rmin)
            continue;

          SiSpacePointForSeed *sps = newSpacePoint(data, sp);
          if (!sps)
            continue;

          int radiusBin = static_cast<int>(sps->radius() * oneOverBinSizeR);
          if (radiusBin > maxBinR)
            radiusBin = maxBinR;

          data.r_ITkSorted[radiusBin].push_back(sps);
          ++data.r_map[radiusBin];
          if (data.r_map[radiusBin] == 1)
            data.r_index[data.nr++] = radiusBin;
          ++data.ns;
        }          
      }             
    }              
  }
}

newOneSeed()

void ITk::SiSpacePointsSeedMaker::newOneSeed ( EventData & data, SiSpacePointForSeed *& p1, SiSpacePointForSeed *& p2, SiSpacePointForSeed *& p3, float z, float seedCandidateQuality ) const

private

get the worst seed so far

There are three cases where we simply add our new seed to the list and push it into the map: a) we have not yet reached our max number of seeds

b) we have reached the max number but always want to keep confirmed seeds and the new seed is a confirmed one, with worse quality than the worst one so far

c) we have reached the max number but always want to keep confirmed seeds and the new seed of higher quality than the worst one so far, with the latter however being confirmed

otherwise, we check if there is a poorer-quality seed that we can kick out

Overwrite the parameters of the worst seed with the new one

re-insert it with its proper quality to make sure it ends up in the right place

and remove the entry with the old quality to avoid duplicates

Definition at line 2560 of file ITkSiSpacePointsSeedMaker.cxx.

{
  float worstQualityInMap = std::numeric_limits<float>::min();
  SiSpacePointsProSeed *worstSeedSoFar = nullptr;
  if (!data.ITkMapOneSeeds.empty())
  {
    std::multimap<float, SiSpacePointsProSeed *>::reverse_iterator l = data.ITkMapOneSeeds.rbegin();
    worstQualityInMap = (*l).first;
    worstSeedSoFar = (*l).second;
  }
  if (data.nOneSeeds < data.maxSeedsPerSP
      || (m_useSeedConfirmation && data.keepAllConfirmedSeeds && worstQualityInMap <= seedCandidateQuality && isConfirmedSeed(p1, p3, seedCandidateQuality) && data.nOneSeeds < data.seedPerSpCapacity)
      || (m_useSeedConfirmation && data.keepAllConfirmedSeeds && worstQualityInMap > seedCandidateQuality && isConfirmedSeed(worstSeedSoFar->spacepoint0(), worstSeedSoFar->spacepoint2(), worstQualityInMap) && data.nOneSeeds < data.seedPerSpCapacity))
  {
    data.ITkOneSeeds[data.nOneSeeds].set(p1, p2, p3, z);
    data.ITkMapOneSeeds.insert(std::make_pair(seedCandidateQuality, &data.ITkOneSeeds[data.nOneSeeds]));
    ++data.nOneSeeds;
  }

  else if (worstQualityInMap > seedCandidateQuality)
  {
    worstSeedSoFar->set(p1, p2, p3, z);
    std::multimap<float, SiSpacePointsProSeed *>::iterator
        i = data.ITkMapOneSeeds.insert(std::make_pair(seedCandidateQuality, worstSeedSoFar));
    for (++i; i != data.ITkMapOneSeeds.end(); ++i)
    {
      if ((*i).second == worstSeedSoFar)
      {
        data.ITkMapOneSeeds.erase(i);
        return;
      }
    }
  }
}

newOneSeedQ()

void ITk::SiSpacePointsSeedMaker::newOneSeedQ ( EventData & data, SiSpacePointForSeed *& p1, SiSpacePointForSeed *& p2, SiSpacePointForSeed *& p3, float z, float seedCandidateQuality ) const

private

get the worst seed so far

There are three cases where we simply add our new seed to the list and push it into the map: a) we have not yet reached our max number of seeds

b) we have reached the max number but always want to keep confirmed seeds and the new seed is a confirmed one, with worse quality than the worst one so far

c) we have reached the max number but always want to keep confirmed seeds and the new seed of higher quality than the worst one so far, with the latter however being confirmed

otherwise, we check if there is a poorer-quality seed that we can kick out

Overwrite the parameters of the worst seed with the new one

re-insert it with its proper quality to make sure it ends up in the right place

and remove the entry with the old quality to avoid duplicates

Definition at line 2609 of file ITkSiSpacePointsSeedMaker.cxx.

{
  float worstQualityInMap = std::numeric_limits<float>::min();
  SiSpacePointsProSeed *worstSeedSoFar = nullptr;
  if (!data.ITkMapOneSeedsQ.empty())
  {
    std::multimap<float, SiSpacePointsProSeed *>::reverse_iterator l = data.ITkMapOneSeedsQ.rbegin();
    worstQualityInMap = (*l).first;
    worstSeedSoFar = (*l).second;
  }
  if (data.nOneSeedsQ < data.maxSeedsPerSP
      || (m_useSeedConfirmation && data.keepAllConfirmedSeeds && worstQualityInMap <= seedCandidateQuality && isConfirmedSeed(p1, p3, seedCandidateQuality) && data.nOneSeedsQ < data.seedPerSpCapacity)
      || (m_useSeedConfirmation && data.keepAllConfirmedSeeds && worstQualityInMap > seedCandidateQuality && isConfirmedSeed(worstSeedSoFar->spacepoint0(), worstSeedSoFar->spacepoint2(), worstQualityInMap) && data.nOneSeedsQ < data.seedPerSpCapacity))
  {
    data.ITkOneSeedsQ[data.nOneSeedsQ].set(p1, p2, p3, z);
    data.ITkMapOneSeedsQ.insert(std::make_pair(seedCandidateQuality, &data.ITkOneSeedsQ[data.nOneSeedsQ]));
    ++data.nOneSeedsQ;
  }

  else if (worstQualityInMap > seedCandidateQuality)
  {
    worstSeedSoFar->set(p1, p2, p3, z);
    std::multimap<float, SiSpacePointsProSeed *>::iterator
        i = data.ITkMapOneSeedsQ.insert(std::make_pair(seedCandidateQuality, worstSeedSoFar));
    for (++i; i != data.ITkMapOneSeedsQ.end(); ++i)
    {
      if ((*i).second == worstSeedSoFar)
      {
        data.ITkMapOneSeedsQ.erase(i);
        return;
      }
    }
  }
}

newOneSeedWithCurvaturesComparison()

void ITk::SiSpacePointsSeedMaker::newOneSeedWithCurvaturesComparison ( EventData & data, SiSpacePointForSeed *& SPb, SiSpacePointForSeed *& SP0, float Zob ) const

private

Definition at line 2663 of file ITkSiSpacePointsSeedMaker.cxx.

{
  const float dC = .00003;
 
  bool pixb = !SPb->spacepoint->clusterList().second;
 
  std::sort(data.ITkCmSp.begin(), data.ITkCmSp.end(), comCurvature());
  std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator j, jn, i = data.ITkCmSp.begin(), ie = data.ITkCmSp.end();
  jn = i;
 
  for (; i != ie; ++i)
  {
    float u = (*i).second->param();
    bool pixt = !(*i).second->spacepoint->clusterList().second;
    if (pixt && std::abs(SPb->z() - (*i).second->z()) > m_dzmaxPPP)
      continue;
 
    const Trk::Surface *Sui = (*i).second->sur();
    float Ri = (*i).second->radius();
    float Ci1 = (*i).first - dC;
    float Ci2 = (*i).first + dC;
    float Rmi = 0.;
    float Rma = 0.;
    bool in = false;
 
    if (!pixb)
      u -= 400.;
    else if (pixt)
      u -= 200.;
 
    for (j = jn; j != ie; ++j)
    {
      if (j == i)
        continue;
      if ((*j).first < Ci1)
      {
        jn = j;
        ++jn;
        continue;
      }
      if ((*j).first > Ci2)
        break;
      if ((*j).second->sur() == Sui)
        continue;
 
      float Rj = (*j).second->radius();
      if (std::abs(Rj - Ri) < m_drmin)
        continue;
 
      if (in)
      {
        if (Rj > Rma)
          Rma = Rj;
        else if (Rj < Rmi)
          Rmi = Rj;
        else
          continue;
        if ((Rma - Rmi) > 20.)
        {
          u -= 200.;
          break;
        }
      }
      else
      {
        in = true;
        Rma = Rmi = Rj;
        u -= 200.;
      }
    }
    if (u > m_umax)
      continue;
 
    newOneSeed(data, SPb, SP0, (*i).second, Zob, u);
  }
  data.ITkCmSp.clear();
}

newOneSeedWithCurvaturesComparisonPPP()

void ITk::SiSpacePointsSeedMaker::newOneSeedWithCurvaturesComparisonPPP ( EventData & data, SiSpacePointForSeed *& SPb, SiSpacePointForSeed *& SP0, float Zob ) const

private

sort common SP by curvature

check all possible common top SP

form a curvature interval cut

Now we look at the other SP candidates and try to find a confirmation seed, including the same centre/lower SP and giving a compatible curvature, but with the top SP in a different layer

if we are looking at the same SP, skip it

if we have a lower curvature than the minimum, skip - and remember to not bother with this candidate again later, as the vectors are curvature-sorted

abort once the the curvature gets too large

Definition at line 3109 of file ITkSiSpacePointsSeedMaker.cxx.

{
 
  if (m_useSeedConfirmation)
  {
    newOneSeedWithCurvaturesComparisonSeedConfirmation(data, SPb, SP0, Zob);
  }
 
  else
  {
 
    static const float curvatureInterval = .00003;

    if (data.ITkCmSp.size() > 2)
      std::sort(data.ITkCmSp.begin(), data.ITkCmSp.end(), comCurvature());
 
    std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_otherSP;
    std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_commonTopSP = data.ITkCmSp.begin(), ie = data.ITkCmSp.end();
    std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_startInnerLoop = it_commonTopSP;
 
    float Lt[4];
 
    float Qmin = 1.e20;
    float Rb = 2. * SPb->radius();
    int NTc(2);
    if (Rb > 280.) {
      NTc = 1;
    }
 
    SiSpacePointForSeed *SPmin = nullptr;
    bool Qm = Rb < 120. || std::abs(Zob) > 150.;

    for (; it_commonTopSP != ie; ++it_commonTopSP)
    {
 
      SiSpacePointForSeed *SPt = (*it_commonTopSP).second;
      int NT = 1;
      Lt[0] = SPt->dR();
      float seedIP = SPt->param();

      float minCurvature = (*it_commonTopSP).first - curvatureInterval;
      float maxCurvature = (*it_commonTopSP).first + curvatureInterval;

 
      for (it_otherSP = it_startInnerLoop; it_otherSP != ie; ++it_otherSP)
      {
        if (it_otherSP == it_commonTopSP)
          continue;
        if ((*it_otherSP).first < minCurvature)
        {
          it_startInnerLoop = it_otherSP;
          ++it_startInnerLoop;
          continue;
        }
        if ((*it_otherSP).first > maxCurvature)
          break;
 
        float L = (*it_otherSP).second->dR();
 
        int k = 0;
        for (; k != NT; ++k)
        {
          if (std::abs(L - Lt[k]) < 20.)
            break;
        }
        if (k == NT)
        {
          Lt[NT] = L;
          if (++NT == 4)
            break;
        }
      }
 
      int dN = NT - NTc;
      if (dN < 0 || (data.nOneSeedsQ && !dN))
        continue;
      if (Qm && !dN && seedIP > 1.)
        continue;
 
      // ITk seed quality used so far
      float Q = 100. * seedIP + (std::abs(Zob) - float(NT) * 100.);
      if (Q > SPb->quality() && Q > SP0->quality() && Q > SPt->quality())
        continue;
 
      if (dN)
        newOneSeedQ(data, SPb, SP0, SPt, Zob, Q);
      else if (Q < Qmin)
      {
        Qmin = Q;
        SPmin = SPt;
      }
    } 
    if (SPmin && !data.nOneSeedsQ)
      newOneSeed(data, SPb, SP0, SPmin, Zob, Qmin);
    data.ITkCmSp.clear();
  }
}

newOneSeedWithCurvaturesComparisonSeedConfirmation()

void ITk::SiSpacePointsSeedMaker::newOneSeedWithCurvaturesComparisonSeedConfirmation ( EventData & data, SiSpacePointForSeed *& SPb, SiSpacePointForSeed *& SP0, float Zob ) const

private

sort common SP by curvature

check all possible common top SP

the seed quality is set to d0 initially

check the surface the hit is on

form a curvature interval cut

Note: The score modifiers used here have the purpose of separating the candidates into classes / groups disjoint from each other. So the score increment (200 by default) should exceed the maximum |d0| (base score) we expect to encounter to avoid overlap. For LRT, we may want to tune this!

if we have a SSS seed, boost the quality score by 400

if we have a PPP, boost the quality by 200

Now we look at the other SP candidates and try to find a confirmation seed, including the same centre/lower SP and giving a compatible curvature, but with the top SP in a different layer

if we are looking at the same SP, skip it

if we have a lower curvature than the minimum, skip - and remember to not bother with this candidate again later, as the vectors are curvature-sorted

abort once the the curvature gets too large

if both SP are on the surface, skip it

if the other SP is too close to the current top one, skip

kick this seed candidate if the score is too high (lower values = better)

if we have PPS seeds and no confirmation SP exists (which would give the -200 bonus) or the hits on this seed were already used on a higher quality PPP/SSS seed, kick this one

If we have a non-confirmed seed, apply a stricter d0 cut. This, is determined using the original cut and the score penalty modifier.

PPP seeds

SSS seeds

this is a good seed, save it (unless we have too many seeds per SP)

Definition at line 3220 of file ITkSiSpacePointsSeedMaker.cxx.

{
  static const float curvatureInterval = .00003;
  bool bottomSPisPixel = !SPb->spacepoint->clusterList().second;
  float bottomSPQuality = SPb->quality();
  float centralSPQuality = SP0->quality();

  if (data.ITkCmSp.size() > 2)
    std::sort(data.ITkCmSp.begin(), data.ITkCmSp.end(), comCurvature());
 
  float bottomR = SPb->radius();
  float bottomZ = SPb->z();
 
  std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_otherSP;
  std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_commonTopSP = data.ITkCmSp.begin(), ie = data.ITkCmSp.end();
  std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_startInnerLoop = it_commonTopSP;

  for (; it_commonTopSP != ie; ++it_commonTopSP)
  {
 
    SiSpacePointForSeed *SPt = (*it_commonTopSP).second;
    float seedIP = SPt->param();
    float seedQuality = seedIP + SPt->scorePenalty();
    float originalSeedQuality = seedQuality;
 
    if (m_maxdImpact > 50)
    { //This only applies to LRT
 
      float topR = SPt->radius();
      float topZ = SPt->z();
 
      float Zot = std::abs(topR - bottomR) > 10e-9 ? bottomZ - (bottomR - originalSeedQuality) * ((topZ - bottomZ) / (topR - bottomR)) : bottomZ;
 
      float theta1 = std::abs(topR - bottomR) > 10e-9 ? std::atan2(topR - bottomR, topZ - bottomZ) : 0.;
      float eta1 = theta1 > 0 ? -std::log(std::tan(.5 * theta1)) : 0.;
 
      float theta0 = seedIP > 0 ? std::atan2(seedIP, Zot) : 0;
      float eta0 = theta0 > 0 ? -std::log(std::tan(.5 * theta0)) : 0.;
 
      float deltaEta = std::abs(eta1 - eta0); //For LLP daughters, the direction of the track is correlated with the direction of the LLP (which is correlated with the direction of the point of closest approach
      //calculate weighted average of d0 and deltaEta, normalized by their maximum values
      float f = std::min(0.5, originalSeedQuality / 200.); //0.5 and 200 are parameters chosen from a grid scan to optimize efficiency
      seedQuality *= (1 - f) / 300.;
      seedQuality += f * deltaEta / 2.5;
    }
 
    bool topSPisPixel = !SPt->spacepoint->clusterList().second;

    const Trk::Surface *surfaceTopSP = SPt->sur();
    float radiusTopSP = SPt->radius();
    float minCurvature = (*it_commonTopSP).first - curvatureInterval;
    float maxCurvature = (*it_commonTopSP).first + curvatureInterval;


    if (!bottomSPisPixel)
      seedQuality += m_seedScoreBonusSSS;
    else if (topSPisPixel)
      seedQuality += m_seedScoreBonusPPP;

 
    for (it_otherSP = it_startInnerLoop; it_otherSP != ie; ++it_otherSP)
    {
      if (it_otherSP == it_commonTopSP)
        continue;
      if ((*it_otherSP).first < minCurvature)
      {
        it_startInnerLoop = it_otherSP;
        ++it_startInnerLoop;
        continue;
      }
      if ((*it_otherSP).first > maxCurvature)
        break;
      if ((*it_otherSP).second->sur() == surfaceTopSP)
        continue;
      float radiusOtherSP = (*it_otherSP).second->radius();
      if (std::abs(radiusOtherSP - radiusTopSP) < m_drminSeedConf)
        continue;
      // if we have a confirmation seed, we improve the score of the seed.
      seedQuality += m_seedScoreBonusConfirmationSeed;
      // apply confirmation bonus only once
      break;
    }

    if (seedQuality > data.maxScore)
      continue;

    if (bottomSPisPixel != topSPisPixel)
    {
      if (seedQuality > 0. ||
          (seedQuality > bottomSPQuality && seedQuality > centralSPQuality && seedQuality > SPt->quality()))
        continue;
    }
    if (!isConfirmedSeed(SPb, SPt, seedQuality))
    {
      double maxdImpact = m_maxdImpact - (m_dImpactCutSlopeUnconfirmedPPP * SPt->scorePenalty());
      if (!bottomSPisPixel)
        maxdImpact = m_maxdImpactSSS - (m_dImpactCutSlopeUnconfirmedSSS * SPt->scorePenalty());
      if (seedIP > maxdImpact)
        continue;
    }
    newOneSeed(data, SPb, SP0, SPt, Zob, seedQuality);
  } 
  data.ITkCmSp.clear();
}

newOneSeedWithCurvaturesComparisonSSS()

void ITk::SiSpacePointsSeedMaker::newOneSeedWithCurvaturesComparisonSSS ( EventData & data, SiSpacePointForSeed *& SPb, SiSpacePointForSeed *& SP0, float Zob ) const

private

This creates all possible seeds with the passed central and bottom SP, using all top SP candidates which are stored in the data.CmSp member.

Seeds are scored by a quality score seeded by abs(d0), and modified if there is a second-seed confirmation or in case of PPP/SSS topologies. Then, they are written out via the newOneSeed method.

Parameters

[in]	SPb	Bottom Space point for the seed creation
[in]	SP0	Central Space point for the seed creation
[in]	Zob	z0 estimate

sort common SP by curvature

check all possible common top SP

form a curvature interval cut

Now we look at the other SP candidates and try to find a confirmation seed, including the same centre/lower SP and giving a compatible curvature, but with the top SP in a different layer

if we are looking at the same SP, skip it

if we have a lower curvature than the minimum, skip - and remember to not bother with this candidate again later, as the vectors are curvature-sorted

abort once the the curvature gets too large

this is a good seed, save it (unless we have too many seeds per SP)

Definition at line 3022 of file ITkSiSpacePointsSeedMaker.cxx.

{
 
  if (m_useSeedConfirmation)
  {
    newOneSeedWithCurvaturesComparisonSeedConfirmation(data, SPb, SP0, Zob);
  }
 
  else
  {
 
    static const float curvatureInterval = .00003;

    if (data.ITkCmSp.size() > 2)
      std::sort(data.ITkCmSp.begin(), data.ITkCmSp.end(), comCurvature());
 
    std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_otherSP;
    std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_commonTopSP = data.ITkCmSp.begin(), ie = data.ITkCmSp.end();
    std::vector<std::pair<float, SiSpacePointForSeed *>>::iterator it_startInnerLoop = it_commonTopSP;
 
    float Lt[4];

    for (; it_commonTopSP != ie; ++it_commonTopSP)
    {
 
      SiSpacePointForSeed *SPt = (*it_commonTopSP).second;
      int NT = 1;
      Lt[0] = SPt->dR();
      float seedIP = SPt->param();

      float minCurvature = (*it_commonTopSP).first - curvatureInterval;
      float maxCurvature = (*it_commonTopSP).first + curvatureInterval;

 
      for (it_otherSP = it_startInnerLoop; it_otherSP != ie; ++it_otherSP)
      {
        if (it_otherSP == it_commonTopSP)
          continue;
        if ((*it_otherSP).first < minCurvature)
        {
          it_startInnerLoop = it_otherSP;
          ++it_startInnerLoop;
          continue;
        }
        if ((*it_otherSP).first > maxCurvature)
          break;
 
        float L = (*it_otherSP).second->dR();
 
        int k = 0;
        for (; k != NT; ++k)
        {
          if (std::abs(L - Lt[k]) < 20.)
            break;
        }
        if (k == NT)
        {
          Lt[NT] = L;
          if (++NT == 4)
            break;
        }
      }
 
      // ITk seed quality used so far
      float Q = seedIP - float(NT) * 100.;
      if (NT > 2)
        Q -= 100000.;
      newOneSeed(data, SPb, SP0, SPt, Zob, Q);
    } 
    data.ITkCmSp.clear();
  }
}

newRegion() [1/2]

void ITk::SiSpacePointsSeedMaker::newRegion ( const EventContext & ctx, EventData & data, const std::vector< IdentifierHash > & vPixel, const std::vector< IdentifierHash > & vStrip ) const

overridevirtual

build the r-binning.

set the spacepoint iterator to the beginning of the space-point list

Definition at line 313 of file ITkSiSpacePointsSeedMaker.cxx.

{
  if (!m_pixel && !m_strip)
    return;
 
  if (not data.initialized)
    initializeEventData(data, ctx);
  erase(data);
  data.iteration = 0;
  data.trigger = false;
  data.dzdrmin = m_dzdrmin0;
  data.dzdrmax = m_dzdrmax0;
  data.maxScore = m_maxScore;
  data.r_first = 0;
  data.checketa = false;

  float oneOverBinSizeR = 1. / m_binSizeR; //was float irstep = 1.f/m_binSizeR;
  int maxBinR = m_nBinsR - 1;              //was int   irmax  = m_nBinsR-1;

  data.i_ITkSpacePointForSeed = data.l_ITkSpacePointForSeed.begin();
 
  SG::ReadHandle<Trk::PRDtoTrackMap> prd_to_track_map;
  const Trk::PRDtoTrackMap *prd_to_track_map_cptr = nullptr;
  if (!m_prdToTrackMap.key().empty())
  {
    prd_to_track_map = SG::ReadHandle<Trk::PRDtoTrackMap>(m_prdToTrackMap, ctx);
    if (!prd_to_track_map.isValid())
    {
      ATH_MSG_ERROR("Failed to read PRD to track association map: " << m_prdToTrackMap.key());
    }
    prd_to_track_map_cptr = prd_to_track_map.cptr();
  }
 
  // Get pixels space points containers from store gate
  //
  if (m_pixel && !vPixel.empty())
  {
 
    SG::ReadHandle<SpacePointContainer> spacepointsPixel{m_spacepointsPixel, ctx};
    if (spacepointsPixel.isValid())
    {
      data.maxSeedsPerSP = m_maxOneSizePPP;
 
      // Loop through all trigger collections
      //
      for (const IdentifierHash &l : vPixel)
      {
        const auto *w = spacepointsPixel->indexFindPtr(l);
        if (w == nullptr)
          continue;
        for (const Trk::SpacePoint *sp : *w)
        {
          float r = sp->r();
          if ((prd_to_track_map_cptr && isUsed(sp, *prd_to_track_map_cptr)) || r > m_r_rmax || r < m_r_rmin)
            continue;
          SiSpacePointForSeed *sps = newSpacePoint(data, sp);
          int ir = static_cast<int>(sps->radius() * oneOverBinSizeR);
          if (ir > maxBinR)
            ir = maxBinR;
          data.r_ITkSorted[ir].push_back(sps);
          ++data.r_map[ir];
          if (data.r_map[ir] == 1)
            data.r_index[data.nr++] = ir;
          ++data.ns;
        }
      }
    }
  }
 
  // Get strip space points containers from store gate
  //
  if (m_strip && !vStrip.empty())
  {
    data.maxSeedsPerSP = m_maxOneSizeSSS;
 
    SG::ReadHandle<SpacePointContainer> spacepointsStrip{m_spacepointsStrip, ctx};
    if (spacepointsStrip.isValid())
    {
 
      // Loop through all trigger collections
      //
      for (const IdentifierHash &l : vStrip)
      {
        const auto *w = spacepointsStrip->indexFindPtr(l);
        if (w == nullptr)
          continue;
        for (const Trk::SpacePoint *sp : *w)
        {
          float r = sp->r();
          if ((prd_to_track_map_cptr && isUsed(sp, *prd_to_track_map_cptr)) || r > m_r_rmax || r < m_r_rmin)
            continue;
          SiSpacePointForSeed *sps = newSpacePoint(data, sp);
          int ir = static_cast<int>(sps->radius() * oneOverBinSizeR);
          if (ir > maxBinR)
            ir = maxBinR;
          data.r_ITkSorted[ir].push_back(sps);
          ++data.r_map[ir];
          if (data.r_map[ir] == 1)
            data.r_index[data.nr++] = ir;
          ++data.ns;
        }
      }
    }
  }
}

newRegion() [2/2]

void ITk::SiSpacePointsSeedMaker::newRegion ( const EventContext & ctx, EventData & data, const std::vector< IdentifierHash > & vPixel, const std::vector< IdentifierHash > & vStrip, const IRoiDescriptor & iRD ) const

overridevirtual

Definition at line 425 of file ITkSiSpacePointsSeedMaker.cxx.

{
  constexpr float twoPi = 2. * M_PI;
 
   newRegion(ctx, data, vPixel, vStrip);
   data.trigger = true;
 
   double dzdrmin = 1. / std::tan(2. * std::atan(std::exp(-IRD.etaMinus())));
   double dzdrmax = 1. / std::tan(2. * std::atan(std::exp(-IRD.etaPlus())));
 
   data.zminB = IRD.zedMinus() - data.zbeam[0]; // min bottom Z
   data.zmaxB = IRD.zedPlus() - data.zbeam[0];  // max bottom Z
   data.zminU = data.zminB + 550. * dzdrmin;
   data.zmaxU = data.zmaxB + 550. * dzdrmax;
   double fmax = IRD.phiPlus();
   double fmin = IRD.phiMinus();
   if (fmin > fmax)
     fmin -= twoPi;
   data.ftrig = (fmin + fmax) * .5;
   data.ftrigW = (fmax - fmin) * .5;
}

newSeed()

void ITk::SiSpacePointsSeedMaker::newSeed ( EventData & data, SiSpacePointForSeed *& p1, SiSpacePointForSeed *& p2, float z )

staticprivate

Definition at line 2937 of file ITkSiSpacePointsSeedMaker.cxx.

{
  SiSpacePointForSeed *p3 = nullptr;
 
  if (data.i_ITkSeedEnd != data.i_ITkSeeds.end())
  {
    SiSpacePointsProSeed *s = &(*data.i_ITkSeedEnd++);
    s->set(p1, p2, p3, z);
  }
  else
  {
    data.i_ITkSeeds.emplace_back(p1, p2, p3, z);
    data.i_ITkSeedEnd = data.i_ITkSeeds.end();
  }
}

newSpacePoint() [1/2]

SiSpacePointForSeed * ITk::SiSpacePointsSeedMaker::newSpacePoint ( EventData & data, const Trk::SpacePoint *const & sp ) const

private

Create a SiSpacePointForSeed from the space point.

This will also add the point to the data object's l_spforseed list and update its i_spforseed iterator to point to the entry after the new SP for further additions. Returns a nullptr if the SP fails the eta cut, should we apply one

Parameters

[in,out]	data	Provides beam spot location, receives updates to the l_spforseed and i_spforseed members
[in]	sp	Input space point.

Definition at line 2866 of file ITkSiSpacePointsSeedMaker.cxx.

{
  std::array<float, 15> r;
  return newSpacePoint(data, sp, r, true);
}

newSpacePoint() [2/2]

SiSpacePointForSeed * ITk::SiSpacePointsSeedMaker::newSpacePoint ( EventData & data, const Trk::SpacePoint *const & sp, std::span< float, 15 > r, bool usePixStripInform = false ) const

private

r will store the coordinates of the space point relative to the beam spot

if needed, apply eta criterion

If we have previously populated the list and just reset the iterator when re-initialising the data object, then we re-use existing entries

re-use existing entry at the current location

and then update the existing entry with the new SP and location. Unfortunately, set still relies on C-arrays...

otherwise, the list needs to grow

set our return pointer

and make sure to update the iterator

Definition at line 2872 of file ITkSiSpacePointsSeedMaker.cxx.

{
 
  SiSpacePointForSeed *sps = nullptr;

  convertToBeamFrameWork(data, sp, r.data());

  if (data.checketa)
  {
    float z = (std::abs(r[2]) + m_zmax);
    float x = r[0] * data.dzdrmin;
    float y = r[1] * data.dzdrmin;
    if ((z * z) < (x * x + y * y))
      return sps;
  }
 
  if (m_fastTracking)
  {
    float R2 = r[0] * r[0] + r[1] * r[1];
    // cotTheta=18.2855 corresponds to eta=3.6
    if (std::abs(r[2]) > m_dzMaxFast && R2 < m_R2MaxFast && std::abs(r[2]) < 18.2855 * std::sqrt(R2))
      return nullptr;
    if (std::abs(r[2]) - m_zmax > data.dzdrmax * std::sqrt(R2))
      return nullptr;
  }
 
  if (usePixStripInform)
  {
    if (!sp->clusterList().second)
      pixInform(sp, r.data());
    else
      stripInform(data, sp, r.data());
  }

  if (data.i_ITkSpacePointForSeed != data.l_ITkSpacePointForSeed.end())
  {
    sps = &(*data.i_ITkSpacePointForSeed++);
    sps->set(sp, r);
  }
  else
  {
    data.l_ITkSpacePointForSeed.emplace_back(sp, r);
    sps = &(data.l_ITkSpacePointForSeed.back());
    data.i_ITkSpacePointForSeed = data.l_ITkSpacePointForSeed.end();
  }
 
  return sps;
}

newVertices()

bool ITk::SiSpacePointsSeedMaker::newVertices ( EventData & data, const std::list< Trk::Vertex > & lV ) const

private

reset the isvertex flag

if we had no vertices before and have none now, we can exit right away

clean up the vertex list

if we have no vertices now, we can exit

otherwise, update the data with the new vertices

and also update the z interval, adding 20mm before/after the first/last vertex in z make sure not to extend the interval beyond the user-configured z interval.

Definition at line 787 of file ITkSiSpacePointsSeedMaker.cxx.

{
 
  unsigned int s1 = data.l_vertex.size();
  unsigned int s2 = lV.size();

  data.isvertex = false;
  if (s1 == 0 && s2 == 0)
    return false;

  data.l_vertex.clear();
  if (s2 == 0)
    return false;

  data.isvertex = true;
  for (const Trk::Vertex &v : lV)
  {
    data.l_vertex.insert(static_cast<float>(v.position().z()));
  }

  data.zminU = (*data.l_vertex.begin()) - 20.;
  if (data.zminU < m_zmin)
    data.zminU = m_zmin;
  data.zmaxU = (*data.l_vertex.rbegin()) + 20.;
  if (data.zmaxU > m_zmax)
    data.zmaxU = m_zmax;
 
  return false;
}

next()

const InDet::SiSpacePointsSeed * ITk::SiSpacePointsSeedMaker::next ( const EventContext & ctx, EventData & data ) const

overridevirtual

This only holds if we call next() without manually calling newEvent/find3Sp

If we are out of seeds, call findNext to see if we can find more.

findNext will call production3Sp again IF data.endlist is false, which is only the case if the last run of production3Sp did not run to the end or if we did not run seed finding before For run-3 offline, this will not do anything.

if no new seeds were found, exit

iterate until we find a valid seed satisfying certain quality cuts in set3

then return this next seed candidate

same as above for 2SP

Definition at line 2798 of file ITkSiSpacePointsSeedMaker.cxx.

{
  if (not data.initialized)
    initializeEventData(data, ctx);
 
  if (data.nspoint == 3)
  {
    do
    {
      if (data.i_ITkSeed == data.i_ITkSeedEnd)
      {
        findNext(data);
        //cppcheck-suppress identicalInnerCondition
        if (data.i_ITkSeed == data.i_ITkSeedEnd)
          return nullptr;
      }

    } while (!(*data.i_ITkSeed++).set3(data.seedOutput, 1./(1000. * data.K)));
    return &data.seedOutput;
  }
  else
  {
    if (data.i_ITkSeed == data.i_ITkSeedEnd)
    {
      findNext(data);
      //cppcheck-suppress identicalInnerCondition
      if (data.i_ITkSeed == data.i_ITkSeedEnd)
        return nullptr;
    }
    (*data.i_ITkSeed++).set2(data.seedOutput);
    return &data.seedOutput;
  }
  return nullptr;
}

operator=()

SiSpacePointsSeedMaker & ITk::SiSpacePointsSeedMaker::operator= ( const SiSpacePointsSeedMaker & )

privatedelete

pixInform()

void ITk::SiSpacePointsSeedMaker::pixInform ( const Trk::SpacePoint * sp, float * r )

staticprivate

Definition at line 1349 of file ITkSiSpacePointsSeedMaker.cxx.

{
  const InDet::SiCluster *cl = static_cast<const InDet::SiCluster *>(sp->clusterList().first);
  const InDetDD::SiDetectorElement *de = cl->detectorElement();
  const Amg::Transform3D &Tp = de->surface().transform();
  r[3] = float(Tp(0, 2));
  r[4] = float(Tp(1, 2));
  r[5] = float(Tp(2, 2));
}

production2Sp()

void ITk::SiSpacePointsSeedMaker::production2Sp ( EventData & data ) const

private

Definition at line 1445 of file ITkSiSpacePointsSeedMaker.cxx.

{
  ATH_MSG_WARNING("ITk::SiSpacePointsSeedMaker::production2Sp not implemented!");
}

production3Sp()

void ITk::SiSpacePointsSeedMaker::production3Sp ( EventData & data ) const

private

we need at least 3 SP in our phi-z binning, otherwise can't build 3-SP seeds

This method will run a separate seed formation round for each phi-Z region, taking the central SP from there and allowing the top/bottom SP to come from either the same or certain neighbouring bins.

The search in each region is performed in the overload of this method with the extended signature below. Here, we implement the loop over the 2D regions

Order how we walk across z. 0-4 are negative z, 5 is central z, 6-10 are positive z. 0 1 2 3 4 5 6 7 8 9 10 z bin index --------------------------------------> Z[mm] Z=-2500 IP,Z=0 Z=+2500

prepare arrays to store the iterators over the SP containers for all neighbouring cells we wish to consider in the seed formation

counter for the found

prevent another pass from being run when we run out of Seeds

Loop through all azimuthal regions

For each azimuthal region loop through all Z regions

If we had to abort a previous run, continue where we left off

note that this loop follows the order within 'zBinIndex', not the ascending order of z regions. We start in the centre, not at -2500 mm, and then move outward.

can skip the rest if this particular 2D bin is empty

count how many non-emtpy cells should be searched for the top and bottom neighbour

walk through the cells in phi-z we wish to consider for the bottom SP search. Typically, this will be 3 adjacent phi bins (including the one of the central SP) and possibly neighbours in z on side towards the IP or on both sides, depdending on the z region we are in

only do something if this cell is populated

plug the begin and end iterators to the SP in the cell into our array

walk through the cells in phi-z we wish to consider for the top SP search. Typically, this will be 3 adjacent phi bins (including the one of the central SP) and possibly neighbours in z on the side opposed to the IP or on both sides, depdending on the z region we are in

only do something if this cell is populated

plug the begin and end iterators to the SP in the cell into our array

now run the seed search for the current phi-z bin.

If we exceed the seed capacity, we stop here. Save where we were in z and phi, and set endlist to false. This will trigger another run of production3Sp when The client calls next() after processing all vertices seen so far (freeing up capacity).

Processed all seeds there are without aborting - no re-run needed!

Definition at line 1454 of file ITkSiSpacePointsSeedMaker.cxx.

{
  if (data.nsaz < 3)
    return;


  const std::array<int, arraySizeZ> zBinIndex_SSS{5, 6, 4, 7, 3, 8, 2, 9, 1, 10, 0};
  const std::array<int, arraySizeZ> zBinIndex_PPP_fast{0, 10, 1, 9, 2, 8, 5, 3, 7, 4, 6};
  const std::array<int, arraySizeZ> zBinIndex_PPP_long{0, 1, 2, 3, 10, 9, 8, 7, 5, 4, 6};
  const auto zBinIndex_PPP = m_fastTracking ? zBinIndex_PPP_fast : zBinIndex_PPP_long;
  // Fast tracking runs a single iteration, either pixel or strip
  // Default tracking runs a 0-th iteration for strip then a 1-st for pixel
  bool isPixel = (m_fastTracking && m_pixel) || data.iteration == 1;
  const auto zBinIndex = isPixel ? zBinIndex_PPP : zBinIndex_SSS;
 
  const float RTmax[11] = { 80., 200., 200., 200., 250., 250., 250., 200., 200., 200., 80.};
  const float RTmin[11] = { 40., 40., 70., 70., 70., 70., 70., 70., 70., 40., 40.};

  std::array<std::vector<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> iter_topCands;
  std::array<std::vector<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> iter_endTopCands;
  std::array<std::vector<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> iter_bottomCands;
  std::array<std::vector<SiSpacePointForSeed *>::iterator, arraySizeNeighbourBins> iter_endBottomCands;
 
  int nPhiBins;
  std::array<int, arraySizePhiZ> nNeighbourCellsBottom{};
  std::array<int, arraySizePhiZ> nNeighbourCellsTop{};
  //coverity[STACK_USE]
  std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> neighbourCellsBottom{};
  // Local variable neighbourCellsTop uses 79200 bytes of stack space,
  //coverity[STACK_USE]
  std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> neighbourCellsTop{};
 
  if (isPixel)
  {
    nPhiBins = m_maxPhiBinPPP;
    nNeighbourCellsBottom = m_nNeighbourCellsBottomPPP;
    nNeighbourCellsTop = m_nNeighbourCellsTopPPP;
    neighbourCellsBottom = m_neighbourCellsBottomPPP;
    neighbourCellsTop = m_neighbourCellsTopPPP;
  }
  else
  {
    nPhiBins = m_maxPhiBinSSS;
    nNeighbourCellsBottom = m_nNeighbourCellsBottomSSS;
    nNeighbourCellsTop = m_nNeighbourCellsTopSSS;
    neighbourCellsBottom = m_neighbourCellsBottomSSS;
    neighbourCellsTop = m_neighbourCellsTopSSS;
  }

  int nseed = 0;
  data.endlist = true;

  for (int phiBin = data.fNmin; phiBin <= nPhiBins; ++phiBin)
  {

    int z = (m_fastTracking && m_pixel) ? 2 : 0;
    if (!data.endlist)
      z = data.zMin;

    for (; z < arraySizeZ; ++z)
    {
 
      if (m_fastTracking && m_pixel)
      {
        data.RTmax = RTmax[ zBinIndex[z] ];
        data.RTmin = RTmin[ zBinIndex[z] ];
      }
 
      int phiZbin = phiBin * arraySizeZ + zBinIndex[z];

      if (!data.rfz_map[phiZbin])
        continue;

      int numberBottomCells = 0;
      int numberTopCells = 0;

      for (int neighbourCellNumber = 0; neighbourCellNumber < nNeighbourCellsBottom[phiZbin]; ++neighbourCellNumber)
      {
 
        int theNeighbourCell = neighbourCellsBottom[phiZbin][neighbourCellNumber];
        if (!data.rfz_map[theNeighbourCell])
          continue;
        iter_bottomCands[numberBottomCells] = data.rfz_ITkSorted[theNeighbourCell].begin();
        iter_endBottomCands[numberBottomCells++] = data.rfz_ITkSorted[theNeighbourCell].end();
      }

      for (int neighbourCellNumber = 0; neighbourCellNumber < nNeighbourCellsTop[phiZbin]; ++neighbourCellNumber)
      {
 
        int theNeighbourCell = neighbourCellsTop[phiZbin][neighbourCellNumber];
        if (!data.rfz_map[theNeighbourCell])
          continue;
        iter_topCands[numberTopCells] = data.rfz_ITkSorted[theNeighbourCell].begin();
        iter_endTopCands[numberTopCells++] = data.rfz_ITkSorted[theNeighbourCell].end();
      }

      if (!data.trigger)
      {
        if (isPixel)
          production3SpPPP(data, iter_bottomCands, iter_endBottomCands, iter_topCands, iter_endTopCands, numberBottomCells, numberTopCells, nseed);
        else
          production3SpSSS(data, iter_bottomCands, iter_endBottomCands, iter_topCands, iter_endTopCands, numberBottomCells, numberTopCells, nseed);
      }
      else
        production3SpTrigger(data, iter_bottomCands, iter_endBottomCands, iter_topCands, iter_endTopCands, numberBottomCells, numberTopCells, nseed);
    }

    if (nseed >= m_maxsize)
    {
      data.endlist = false;
      data.fNmin = phiBin + 1;
      return;
    }
  }

  data.endlist = true;
}

production3SpPPP()

void ITk::SiSpacePointsSeedMaker::production3SpPPP ( EventData & data, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_bottomCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_endBottomCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_topCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_endTopCands, const int numberBottomCells, const int numberTopCells, int & nseed ) const

private

This method implements the seed search for a single phi-Z region of the detector. The central SP is taken from the region, while the top and bottom SP are allowed to come from either the same or a range of neighbouring cells.

iterator across the candidates for the central space point.

Next, we work out where we are within the ATLAS geometry. This will help us identify which space-points we need to consider as potential central points of a seed.

find the first central SP candidate above the minimum radius.

for the top candidates in the central phi-Z bin, we do not need to start at a smaller radius than the lowest-r valid central SP candidate

prepare cut values

keep track of the SP storace capacity. Extend it needed (should rarely be the case)

Loop through all central space point candidates

global coordinates of the central SP

for the central SP, we veto locations on the last disk - there would be no "outer" hits to complete a seed.

initialise a counter for found bottom links This also serves as an index in the data.SP vector

Top links production Loop over all the cells where we expect to find such SP

loop over each SP in each cell

evaluate the radial distance,

Comparison with vertices Z coordinates straight line extrapolation to r=0

this is effectively a segment-level eta cut - exclude too shallow seed segments

add SP to the list

< inverse distance to central SP

< transformed U coordinate

< transformed V coordinate

<squared Error on 1/tan theta coming from the space-point position errors

if we are exceeding the SP capacity of our data object, make it resize its vectors. Will add 50 slots by default, so rarely should happen more than once per event.

now continue with the bottom SP search. Make the counter start at Nt, as this serves as a running index in the SP list for this seed.

Bottom links production Loop over all the cells where we expect to find such SP

in each cell, loop over the space points

evaluate the radial distance between the central and bottom SP

if the points are too close in r, abort (future ones will be even closer).

Comparison with vertices Z coordinates straight line extrapolation to r=0

this is effectively a segment-level eta cut - exclude too shallow seed segments

add SP to the list

< inverse distance to central SP

< transformed U coordinate

< transformed V coordinate

<squared Error on 1/tan theta coming from the space-point position errors

if we are exceeding the SP capacity of our data object, make it resize its vectors. Will add 50 slots by default, so rarely should happen more than once per event.

if we found no bottom candidates (remember, Nb starts counting at Nt), abort

Three space points comparison first, loop over the bottom point candidates

retrieve the geometrical paranmeters w.r.t the central SP for this candidate

< 1/tanTheta estimate from central+bottom SP

bottom seed index after sorting

< this is the uncertainty in 1/tanTheta on the bottom segment resulting from the position errors in the 2 SP

< v-coordinate of bottom SP

< u-coordinate of bottom SP

< 1+1/tan²theta - converts transverse to total squared pt

< sqrt (1+1/tan²theta) - used to convert pt to |p|

< this, when divided by the 2R², yields an approximated multiple scattering term assuming the measured pt.

< this is an approximate worst case multiple scattering term assuming the lowest pt we allow and the estimated theta angle

max IP

inner loop over the top point candidates

Apply a cut on the compatibility between the r-z slope of the two seed segments. This is done by comparing the squared difference between slopes, and comparing to the squared uncertainty in this difference - we keep a seed if the difference is compatible within the assumed uncertainties.

average value of 1/tan(theta), approximate the slope at the location of the central space point

squared error on the difference in tan(theta) due to space point position errors.

pre-computed individual squared errors on 1/tan(theta) for the two segments

mixed term with z-uncertainty on central SP

start out by subtracting from the squared difference in 1/tanTheta the space-point-related squared error

First, we test using a generous scattering term calculated assuming the minimum pt we expect to reconstruct.

The following exploits the transformation u:=x/(x²+y²); v:=y/(x²+y²); This is applied on the x,y coordinates in the frame described above, where the origin is put in the central SP and the x axis defined to point directly away from the IP.

In this transformed u,v frame, what would be our circle in x-y space takes the form of
a linear function V = (-x0/y0) x U + 1/(2y0) =: A x U + B/2. Here, x0 and y0 describe the center point of the circle in the x-y frame. As the origin of the x-y frame (the middle space point of our seed) is on the circle, we have x0²+y0²=R² with circle radius R.

For our seed, we can experimentally obtain A as the slope of the linear function, delta V / delta U, estimated using the delta U and delta V between the top and bottom space point.

B is then obtained by inserting the obtained A into the linear equation for the bottom SP, A x U + B/2 = V --> B = 2(V - A x U0

With x0²+y0²=R², and x0=-A/B and y0=1/B, the radius of the circle is then obtained as R²=(1+A²)/B².

With this radius (and pT) estimate, we can apply our pt cut. Reminder, ipt2K is 1 / (K x 0.9 x pt-cut)², where K translates pt into 2R. So here we can apply the pt cut directly on the (2R)² estimate without the extra overhead of conversion / division. The second check is a refinement of the above Tz compatibility cut, replacing the sigmaSquaredScatteringMinPt scattering contribution which assumes the lowest pt by one based on the actual estimated pt.

The second term in this if-statement applies a second version of the 1/tan(theta) compatibility, this time using a scattering term scaled by the actual measured pt. This refines the cut applied above, following the same logic ("delta² - sigma² ?<=0")

This is an estimate of the transverse impact parameter. The reasoning is that, in the x-y frame with the central SP as origin and the x axis pointing away from the IP, we have for the distance between the IP and the middle of the circle: (x0 - r_central)²+y0² = (R + d0)², with R being the circle radius and r_central the radial location of the central SP, placing the IP at IP at (-r_central, 0).

First simplify using R² =x0²+y0², then apply the approximation d0²/R² ~ 0.

Finally, consider that locally close to the central SP, the circle is parallel to the x axis, so A = 0 --> expand (2R)²=(1+A²)/B² around this point to obtain d0 = r_central x (r_central x B - A). Note that below, the variable R is the radial coordinate fo the central SP, corresponding to r_central in the notation above.

apply d0 cut to seed

evaluate distance the two closest-by SP in this seed candidate

obtain a quality score - start from the d0 estimate, and add a penalty term corresponding to how far the seed segments deviate from a straight line in r-z

record one possible seed candidate, sort by the curvature

store the transverse IP, will later be used as a quality estimator

now apply further cleaning on the seed candidates for this central+bottom pair.

cleared in newOneSeedWithCurvaturesComparisonPPP but need to also be cleared in case previous conditional statement isn't fulfilled

record seeds found in this run

Definition at line 1627 of file ITkSiSpacePointsSeedMaker.cxx.

{


  std::vector<SiSpacePointForSeed *>::iterator iter_centralSP = iter_bottomCands[0];


  for (; iter_centralSP != iter_endBottomCands[0]; ++iter_centralSP)
  {
    if((*iter_centralSP)->radius() > data.RTmin) break;
  }

  iter_topCands[0] = iter_centralSP;
  ++iter_topCands[0];

  const float &ipt2K = data.ipt2K;
  const float &ipt2C = data.ipt2C;
  const float &COFK = data.COFK;
  const float &maxd0cut = m_maxdImpact;
  const float &zmax = data.zmaxU;
  const float &dzdrmax = data.dzdrmax;
  data.ITkCmSp.clear();

  size_t SPcapacity = data.ITkSP.size();

  for (; iter_centralSP != iter_endBottomCands[0]; ++iter_centralSP)
  {
    const float &R = (*iter_centralSP)->radius();
 
    if(R > data.RTmax)
      break;

    const float &X = (*iter_centralSP)->x();
    const float &Y = (*iter_centralSP)->y();
    const float &Z = (*iter_centralSP)->z();

    double absZ = std::abs(Z);
    if (!m_fastTracking && absZ > m_zmaxPPP)
      continue;
 
    float covr0 = (*iter_centralSP)->covr();
    float covz0 = (*iter_centralSP)->covz();
    float Ri = 1. / R;
    float ax = X * Ri;
    float ay = Y * Ri;
    float VR = maxd0cut / (R * R);
    size_t Ntm = 2;
    if (R > m_rmaxPPP)
      Ntm = 1;

    size_t Nt = 0;

    for (int cell = 0; cell < numberTopCells; ++cell)
    {
      std::vector<SiSpacePointForSeed *>::iterator iter_otherSP = iter_topCands[cell], iter_otherSPend = iter_endTopCands[cell];
      if (iter_otherSP == iter_otherSPend) continue;
 
      for(; iter_otherSP!=iter_otherSPend; ++iter_otherSP) {
        if(( (*iter_otherSP)->radius()- R ) >= m_drminPPP) break;
      } 
      iter_topCands[cell]=iter_otherSP; 

      for (; iter_otherSP != iter_endTopCands[cell]; ++iter_otherSP)
      {
        float Rt = (*iter_otherSP)->radius();
        float dR = Rt - R;
 
        const float dz = (*iter_otherSP)->z() - Z;
        const float dZdR = dz / dR;
        const float z0 = Z - R * dZdR;
        if (std::abs(z0) > zmax)
          continue;
 
        float dx = (*iter_otherSP)->x() - X;
        float dy = (*iter_otherSP)->y() - Y;
        float x = dx * ax + dy * ay;
        float y = dy * ax - dx * ay;
        float dxy = x * x + y * y;
        float r2 = 1. / dxy;
        float u = x * r2;
        float v = y * r2;
 
        if (std::abs(R * y) > maxd0cut * x)
        {
          float V0;
          y < 0. ? V0 = VR : V0 = -VR;
          float A = (v - V0) / (u + 1. / R);
          float B = V0 + A / R;
          if ((B * B) > (ipt2K * (1. + A * A)))
            continue;
        }
 
        const float dr = std::sqrt(r2);
        const float tz = dz * dr;
        if (std::abs(tz) > dzdrmax)
          continue;

        data.ITkSP[Nt] = (*iter_otherSP);
        data.R[Nt] = dr;                                                                                        
        data.U[Nt] = u;                                                                                         
        data.V[Nt] = v;                                                                                         
        data.Er[Nt] = ((covz0 + (*iter_otherSP)->covz()) + (tz * tz) * (covr0 + (*iter_otherSP)->covr())) * r2; 
        data.ITkSP[Nt]->setDR(std::sqrt(dxy + dz * dz));
        data.ITkSP[Nt]->setDZDR(dZdR);
        data.Tn[Nt].Fl = tz;
        data.Tn[Nt].In = Nt;

        if (++Nt == SPcapacity)
        {
          size_t increment = 50;
          data.resizeSPCont(increment, InDet::SiSpacePointsSeedMakerEventData::ToolType::ITk);
          SPcapacity = data.ITkSP.size();
        }
      } 
    }   
 
    if (Nt < Ntm)
      continue;

    size_t Nb = Nt;

    for (int cell = 0; cell < numberBottomCells; ++cell)
    {
 
      std::vector<SiSpacePointForSeed*>::iterator iter_otherSP = iter_bottomCands[cell];
 
      for(; iter_otherSP!=iter_endBottomCands[cell]; ++iter_otherSP) {
        if( (R - (*iter_otherSP)->radius()) <= m_drmaxPPP) break;
      }
      iter_bottomCands[cell]=iter_otherSP;

      for (; iter_otherSP != iter_endBottomCands[cell]; ++iter_otherSP)
      {
        const float &Rb = (*iter_otherSP)->radius();
        float dR = R - Rb;

        if (dR < m_drminPPP)
          break;
 
        const float dz = Z - (*iter_otherSP)->z();
        const float dZdR = dz / dR;
        const float z0 = Z - R * dZdR;
        if (std::abs(z0) > zmax)
          continue;
 
        float dx = (*iter_otherSP)->x() - X;
        float dy = (*iter_otherSP)->y() - Y;
        float x = dx * ax + dy * ay;
        float y = dy * ax - dx * ay;
        float dxy = ( x * x + y * y );
        float r2 = 1. / dxy;
        float u = x * r2;
        float v = y * r2;
 
        if (std::abs(R * y) > -maxd0cut * x)
        {
          float V0;
          y > 0. ? V0 = VR : V0 = -VR;
          float A = (v - V0) / (u + 1. / R);
          float B = V0 + A / R;
          if ((B * B) > (ipt2K * (1. + A * A)))
            continue;
        }
 
        const float dr = std::sqrt(r2);
        const float tz = dz * dr;
        if (std::abs(tz) > dzdrmax)
          continue;
 
    //Updated to 45mm for ITk layout 03-00-00
        if (m_fastTracking && (*iter_otherSP)->radius() < 45. && std::abs(tz) > 1.5)
          continue;

        data.ITkSP[Nb] = (*iter_otherSP);
        data.R[Nb] = dr;                                                                                        
        data.U[Nb] = u;                                                                                         
        data.V[Nb] = v;                                                                                         
        data.Er[Nb] = ((covz0 + (*iter_otherSP)->covz()) + (tz * tz) * (covr0 + (*iter_otherSP)->covr())) * r2; 
        data.ITkSP[Nb]->setDR(std::sqrt(dxy + dz * dz));
        data.ITkSP[Nb]->setDZDR(dZdR);
        data.Tn[Nb].Fl = tz;
        data.Tn[Nb].In = Nb;

        if (++Nb == SPcapacity)
        {
          size_t increment = 50;
          data.resizeSPCont(increment, InDet::SiSpacePointsSeedMakerEventData::ToolType::ITk);
          SPcapacity = data.ITkSP.size();
        }
 
      } 
    }   

    if (!(Nb - Nt))
      continue;
 
    sort(data.Tn,0,Nt);
    sort(data.Tn,Nt,Nb-Nt);
 
    data.nOneSeeds = 0;
    data.nOneSeedsQ = 0;
    data.ITkMapOneSeeds.clear();
    data.ITkMapOneSeedsQ.clear();

    size_t it0 = 0;
    for (size_t ib = Nt; ib < Nb; ++ib)
    {
 
      if (it0 == Nt)
        break;

      float Tzb = data.Tn[ib].Fl;       
      int b = data.Tn[ib].In;       
 
      float Rb2r = data.R[b] * covr0;
      float Rb2z = data.R[b] * covz0;
      float Erb = data.Er[b];        
      float Vb = data.V[b];          
      float Ub = data.U[b];          
      float Tzb2 = (1. + Tzb * Tzb); 
      float sTzb2 = std::sqrt(Tzb2); 
 
      float sigmaSquaredScatteringPtDependent = Tzb2 * COFK; 
      float sigmaSquaredScatteringMinPt = Tzb2 * ipt2C;      
      float d0max = maxd0cut;
 
      size_t Nc = 1;
      if (data.ITkSP[b]->radius() > m_rmaxPPP){
        Nc = 0;
      }
      if (data.nOneSeedsQ)
        ++Nc;

      for (size_t it = it0; it < Nt; ++it)
      {
 
        int t = data.Tn[it].In; // index of top seed after sorting
        float Tzt = data.Tn[it].Fl;


        float meanOneOverTanThetaSquare = Tzb * Tzt; // SSS uses arithmetic average, PPP geometric average

        float sigmaSquaredSpacePointErrors = Erb + data.Er[t]                                    
                                             + 2 * Rb2z * data.R[t]                              
                                             + 2 * Rb2r * data.R[t] * meanOneOverTanThetaSquare; // mixed term with r-uncertainy on central SP

        float remainingSquaredDelta = (Tzb - Tzt) * (Tzb - Tzt) - sigmaSquaredSpacePointErrors;

        if (remainingSquaredDelta - sigmaSquaredScatteringMinPt > 0)
        {
          if (Tzb - Tzt < 0.)
            break;
          it0 = it + 1 ;
          continue;
        }

 
        float dU = data.U[t] - Ub;
        if (dU == 0.)
          continue;
        float A = (data.V[t] - Vb) / dU;
        float onePlusAsquare = 1. + A * A;
        float B = Vb - A * Ub;
        float BSquare = B * B;

        if (BSquare > ipt2K * onePlusAsquare)
          continue;
        if (remainingSquaredDelta * onePlusAsquare > BSquare * sigmaSquaredScatteringPtDependent)
        {
          if (Tzb - Tzt < 0.)
            break;
          it0 = it;
          continue;
        }

        float d0 = std::abs((A - B * R) * R);

        if (d0 <= d0max)
        {
          float dr = data.R[b];
          if (data.R[t] < data.R[b])
            dr = data.R[t];
          data.ITkSP[t]->setScorePenalty(std::abs((Tzb - Tzt) / (dr * sTzb2)));
          data.ITkSP[t]->setParam(d0);

          data.ITkCmSp.emplace_back(B / std::sqrt(onePlusAsquare), data.ITkSP[t]);
          if (data.ITkCmSp.size() == 500)
            break;
        }
 
      } 
 
      if (data.ITkCmSp.size() > Nc)
      {
        newOneSeedWithCurvaturesComparisonPPP(data, data.ITkSP[b], (*iter_centralSP), Z - R * Tzb);
      }
      data.ITkCmSp.clear(); 
    }                        
    fillSeeds(data);
    nseed += data.fillOneSeeds;
 
  } 
}

production3SpSSS()

void ITk::SiSpacePointsSeedMaker::production3SpSSS ( EventData & data, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_bottomCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_endBottomCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_topCands, std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_endTopCands, const int numberBottomCells, const int numberTopCells, int & nseed ) const

private

: Seed production from space points.

Production 3 space points seeds for full scan.

This method will try to find 3-SP combinations within a local phi-z region in the detector.

The central SP of the seed will be taken from this region (technically via the first entry of the bottom candidate array, which always points to the phi-z bin of interest itself).

The top SP is allowed to come from the same or one of several close-by phi-Z bins, as is the bottom SP.

All SP collections are expected to be internally sorted in the radial coordinate.

Parameters

[in,out]	data	Event data
[in,out]	iter_bottomCands	collection of iterators over SP collections for up to 9 phi-z cells to consider for the bottom space-point search
[in,out]	iter_endBottomCands	collection of end-iterators over the SP collections for up to 9 phi-z cells to consider for the bottom space-point search
[in,out]	iter_topCands	collection of iterators over SP collections for up to 9 phi-z cells to consider for the top space-point search
[in,out]	iter_endTopCands	collection of end-iterators over the SP collections for up to 9 phi-z cells to consider for the top space-point search
[in]	numberBottomCells	Number of bottom cells to consider. Determines how many entries in iter_(end)bottomCands are expected to be valid.
[in]	numberTopCells	Number of top cells to consider.Determines how many entries in iter_(end)topCands are expected to be valid.
[out]	nseed	Number of seeds found

This method implements the seed search for a single phi-Z region of the detector. The central SP is taken from the region, while the top and bottom SP are allowed to come from either the same or a range of neighbouring cells.

iterator across the candidates for the central space point.

< will be used for iterating over top/bottom SP

Next, we work out where we are within the ATLAS geometry. This will help us identify which space-points we need to consider as potential central points of a seed.

find the first central SP candidate above the minimum radius.

for the top candidates in the central phi-Z bin, we do not need to start at a smaller radius than the lowest-r valid central SP candidate

prepare cut values

keep track of the SP storace capacity. Extend it needed (should rarely be the case)

Loop through all central space point candidates

< stop if we have moved outside our radial region of interest.

global coordinates of the central SP

for the central SP, we veto locations on the last disk - there would be no "outer" hits to complete a seed.

veto the last strip disk

initialise a counter for found bottom links This also serves as an index in the data.SP vector

Top links production Loop over all the cells where we expect to find such SP

evaluate the radial distance,

loop over each SP in each cell

evaluate the radial distance,

if we are to far, the next ones will be even farther, so abort

Comparison with vertices Z coordinates straight line extrapolation to r=0

for LRT: Before adding top SP to the list, apply a cut for LRT

add SP to the list

if we are exceeding the SP capacity of our data object, make it resize its vectors. Will add 50 slots by default, so rarely should happen more than once per event.

if we did not find ANY top SP, or if we exceed the storage capacity, we abort this seed candidate.

now continue with the bottom SP search. Make the counter start at Nt, as this serves as a running index in the SP list for this seed.

Bottom links production Loop over all the cells where we expect to find such SP

in each cell, loop over the space points

evaluate the radial distance between the central and bottom SP

if the points are too close in r, abort (future ones will be even closer).

Comparison with vertices Z coordinates straight line extrapolation to r=0

for LRT: Before adding top SP to the list, apply a cut for LRT

found a bottom SP candidate, write it into the data object

if we are exceeding the SP capacity of our data object, make it resize its vectors. Will add 50 slots by default, so rarely should happen more than once per event.

if we found no bottom candidates (remember, Nb starts counting at Nt), abort

get covariance on r and z for the central SP

build a unit direction vector pointing from the IP to the central SP

check all SP candidates we found during our loop and compute geometrical variables w.r.t the central point.

transform the space point coordinates into a frame centered around the middle SP, where the x axis points away from the detector frame origin

inverse square distance of the candidate space point to the central point

inverse distance of the candidate space point to the central point

estimate slope in z - distance traveled in transverse plane vs z direction. rough estimate of 1/tan theta from 2 points

if we are looking at a bottom SP candidate, flip the sign to account for different direction of flight (from bottom to central)

save this into our data object

< 1/ tan theta

< z0 estimate.

< inverse distance to central SP

< transformed U coordinate

< transformed V coordinate

<squared Error on 1/tan theta coming from the space-point position errors

Three space points comparison first, loop over the bottom point candidates

retrieve the geometrical paranmeters w.r.t the central SP for this candidate

< z0 estimate from central+bottom SP

< 1/tanTheta estimate from central+bottom SP

< this is the uncertainty in 1/tanTheta on the bottom segment resulting from the position errors in the 2 SP

< v-coordinate of bottom SP

< u-coordinate of bottom SP

< 1+1/tan²theta - converts transverse to total squared pt

< sqrt (1+1/tan²theta) - used to convert pt to |p|

< this, when divided by the 2R², yields an approximated multiple scattering term assuming the measured pt.

< this is an approximate worst case multiple scattering term assuming the lowest pt we allow and the estimated theta angle

max IP

inner loop over the top point candidates

The following exploits the transformation u:=x/(x²+y²); v:=y/(x²+y²); This is applied on the x,y coordinates in the frame described above, where the origin is put in the central SP and the x axis defined to point directly away from the IP.

In this transformed u,v frame, what would be our circle in x-y space takes the form of
a linear function V = (-x0/y0) x U + 1/(2y0) =: A x U + B/2. Here, x0 and y0 describe the center point of the circle in the x-y frame. As the origin of the x-y frame (the middle space point of our seed) is on the circle, we have x0²+y0²=R² with circle radius R.

For our seed, we can experimentally obtain A as the slope of the linear function, delta V / delta U, estimated using the delta U and delta V between the top and bottom space point.

B is then obtained by inserting the obtained A into the linear equation for the bottom SP, A x U + B/2 = V --> B = 2(V - A x U0

With x0²+y0²=R², and x0=-A/B and y0=1/B, the radius of the circle is then obtained as R²=(1+A²)/B².

Apply a cut on the compatibility between the r-z slope of the two seed segments. This is done by comparing the squared difference between slopes, and comparing to the squared uncertainty in this difference - we keep a seed if the difference is compatible within the assumed uncertainties.

average value of 1/tan(theta), approximate the slope at the location of the central space point

squared error on the difference in tan(theta) due to space point position errors.

pre-computed individual squared errors on 1/tan(theta) for the two segments

mixed term with z-uncertainty on central SP

start out by subtracting from the squared difference in 1/tanTheta the space-point-related squared error

First, we test using a generous scattering term calculated assuming the minimum pt we expect to reconstruct.

With this radius (and pT) estimate, we can apply our pt cut. Reminder, ipt2K is 1 / (K x 0.9 x pt-cut)², where K translates pt into 2R. So here we can apply the pt cut directly on the (2R)² estimate without the extra overhead of conversion / division. The second check is a refinement of the above Tz compatibility cut, replacing the sigmaSquaredScatteringMinPt scattering contribution which assumes the lowest pt by one based on the actual estimated pt.

The second term in this if-statement applies a second version of the 1/tan(theta) compatibility, this time using a scattering term scaled by the actual measured pt. This refines the cut applied above, following the same logic ("delta² - sigma² ?<=0")

This is an estimate of the transverse impact parameter. The reasoning is that, in the x-y frame with the central SP as origin and the x axis pointing away from the IP, we have for the distance between the IP and the middle of the circle: (x0 - r_central)²+y0² = (R + d0)², with R being the circle radius and r_central the radial location of the central SP, placing the IP at IP at (-r_central, 0).

First simplify using R² =x0²+y0², then apply the approximation d0²/R² ~ 0.

Finally, consider that locally close to the central SP, the circle is parallel to the x axis, so A = 0 --> expand (2R)²=(1+A²)/B² around this point to obtain d0 = r_central x (r_central x B - A). Note that below, the variable R is the radial coordinate fo the central SP, corresponding to r_central in the notation above.

apply d0 cut to seed

evaluate distance the two closest-by SP in this seed candidate

obtain a quality score - start from the d0 estimate, and add a penalty term corresponding to how far the seed segments deviate from a straight line in r-z

record one possible seed candidate, sort by the curvature

store the transverse IP, will later be used as a quality estimator

now apply further cleaning on the seed candidates for this central+bottom pair.

record seeds found in this run

Definition at line 2063 of file ITkSiSpacePointsSeedMaker.cxx.

{


  std::vector<SiSpacePointForSeed *>::iterator iter_centralSP = iter_bottomCands[0];
  std::vector<SiSpacePointForSeed *>::iterator iter_otherSP; 


  for (; iter_centralSP != iter_endBottomCands[0]; ++iter_centralSP)
  {
    if((*iter_centralSP)->radius() > data.RTmin) break;
  }

  iter_topCands[0] = iter_centralSP;
  ++iter_topCands[0];

  const float ipt2K = data.ipt2K;
  const float ipt2C = data.ipt2C;
  const float COFK = data.COFK;
  const float maxd0cut = m_maxdImpactSSS;
  const float zmax = data.zmaxU;
  data.ITkCmSp.clear();

  size_t SPcapacity = data.ITkSP.size();

  for (; iter_centralSP != iter_endBottomCands[0]; ++iter_centralSP)
  {
 
    const float &R = (*iter_centralSP)->radius();
    
    if(R > data.RTmax) break; 

    const float &X = (*iter_centralSP)->x();
    const float &Y = (*iter_centralSP)->y();
    const float &Z = (*iter_centralSP)->z();

    double absZ = std::abs(Z);
    if (absZ > m_zmaxSSS)
      continue;

    size_t Nt = 0;

    for (int cell = 0; cell < numberTopCells; ++cell)
    {
 
      for (iter_otherSP = iter_topCands[cell]; iter_otherSP != iter_endTopCands[cell]; ++iter_otherSP)
      {
        float Rt = (*iter_otherSP)->radius();
        float dR = Rt - R;
        if (dR >= m_drminSSS)
          break;
      }
      iter_topCands[cell] = iter_otherSP;

      for (iter_otherSP = iter_topCands[cell]; iter_otherSP != iter_endTopCands[cell]; ++iter_otherSP)
      {

        float Rt = (*iter_otherSP)->radius();
        float dR = Rt - R;
        if (dR > m_drmaxSSS)
          break;
 
        const float dz = (*iter_otherSP)->z() - Z;
        const float dZdR = dz / dR;

        const float z0 = Z - R * dZdR;
        if (std::abs(dz) > m_dzmaxSSS || std::abs(z0) > zmax)
          continue;

        if(m_isLRT){
          float Ri = 1./R;
          const float ax = X*Ri;
          const float ay = Y*Ri;
          float VR    = m_maxdImpact*Ri*Ri ;
          float dx = (*iter_otherSP)->x() - X;
          float dy = (*iter_otherSP)->y() - Y;
          float x = dx * ax + dy * ay;
          float y = dy * ax - dx * ay;
          
          if(std::abs(R*y) > maxd0cut * x) {
              float r2 = 1. / (x * x + y * y);
              float u   = x*r2        ;
              float v   = y*r2        ;
              const float V0 = (y < 0.) ? VR: -VR;
              float A   = (v-V0)/(u+Ri)          ;
              float B   = V0+A*Ri                ;
              if((B*B) > (ipt2K*(1.+A*A))) continue;
          }
        }

        data.ITkSP[Nt] = (*iter_otherSP);
        data.ITkSP[Nt]->setDZDR(dZdR);
        if (++Nt == SPcapacity)
        {
          data.resizeSPCont();
          SPcapacity = data.ITkSP.size();
        }
      } 
    }   

    if (!Nt)
      continue;

    size_t Nb = Nt;

    for (int cell = 0; cell < numberBottomCells; ++cell)
    {
 
      for(iter_otherSP=iter_bottomCands[cell]; iter_otherSP!=iter_endBottomCands[cell]; ++iter_otherSP) {
        if((R-(*iter_otherSP)->radius()) <= m_drmaxSSS) break;
      }  
      iter_bottomCands[cell]=iter_otherSP;

      for (; iter_otherSP != iter_endBottomCands[cell]; ++iter_otherSP)
      {

        const float &Rb = (*iter_otherSP)->radius();
        float dR = R - Rb;

        if (dR < m_drminSSS)
          break;
 
        const float dz = Z - (*iter_otherSP)->z();
        const float dZdR = dz / dR;

        const float z0 = Z - R * dZdR;
        if (std::abs(dz) > m_dzmaxSSS || std::abs(z0) > zmax)
          continue;

        if(m_isLRT){
          float Ri = 1./R;
          const float ax = X*Ri;
          const float ay = Y*Ri;
          float VR    = m_maxdImpact*Ri*Ri ;
          float dx = (*iter_otherSP)->x() - X;
          float dy = (*iter_otherSP)->y() - Y;
          float x = dx * ax + dy * ay;
          float y = dy * ax - dx * ay;
          
          if(std::abs(R*y) > -maxd0cut * x) {
              float r2 = 1. / (x * x + y * y);
              float u   = x*r2        ;
              float v   = y*r2        ;
              const float V0 = (y < 0.) ? VR: -VR;
              float A   = (v-V0)/(u+Ri)          ;
              float B   = V0+A*Ri                ;
              if((B*B) > (ipt2K*(1.+A*A))) continue;
          }
        }

        data.ITkSP[Nb] = (*iter_otherSP);
        data.ITkSP[Nb]->setDZDR(dZdR);
        if (++Nb == SPcapacity)
        {
          data.resizeSPCont();
          SPcapacity = data.ITkSP.size();
        }
      } 
    }   

    if (!(Nb - Nt))
      continue;

    float covr0 = (*iter_centralSP)->covr();
    float covz0 = (*iter_centralSP)->covz();

    float ax = X / R;
    float ay = Y / R;

    for (size_t i = 0; i < Nb; ++i)
    {
 
      SiSpacePointForSeed *sp = data.ITkSP[i];

      float dx = sp->x() - X;
      float dy = sp->y() - Y;
      float dz = sp->z() - Z;
      float x = dx * ax + dy * ay;
      float y = dy * ax - dx * ay;

      float r2 = 1. / (x * x + y * y);
      float dr = std::sqrt(r2);
      float tz = dz * dr;

      if (i >= Nt)
        tz = -tz;

      data.X[i] = x;
      data.Y[i] = y;
      data.Tz[i] = tz;                                                             
      data.Zo[i] = Z - R * tz;                                                     
      data.R[i] = dr;                                                              
      data.U[i] = x * r2;                                                          
      data.V[i] = y * r2;                                                          
      data.Er[i] = ((covz0 + sp->covz()) + (tz * tz) * (covr0 + sp->covr())) * r2; 
    }
 
    data.nOneSeeds = 0;
    data.nOneSeedsQ = 0;
    data.ITkMapOneSeeds.clear();
    data.ITkMapOneSeedsQ.clear();

    for (size_t b = Nt; b < Nb; ++b)
    {

      float Zob = data.Zo[b]; 
      float Tzb = data.Tz[b]; 
      float Rb2r = data.R[b] * covr0;
      float Rb2z = data.R[b] * covz0;
      float Erb = data.Er[b];        
      float Vb = data.V[b];          
      float Ub = data.U[b];          
      float Tzb2 = (1. + Tzb * Tzb); 
      float sTzb2 = std::sqrt(Tzb2); 
      float Se = 1. / std::sqrt(Tzb2);
      float Ce = Se * Tzb;
      float Sx = Se * ax;
      float Sy = Se * ay;
 
      float sigmaSquaredScatteringPtDependent = Tzb2 * COFK; 
      float sigmaSquaredScatteringMinPt = Tzb2 * ipt2C;      
      float d0max = maxd0cut;

      for (size_t t = 0; t < Nt; ++t)
      {

 
        // Trigger point
        //
        float dU0 = data.U[t] - Ub;
        if (dU0 == 0.)
          continue;
        float A0 = (data.V[t] - Vb) / dU0;
 
        float Cn = Ce * std::sqrt(1. + A0 * A0);
 
        float dn[3] = {Sx - Sy * A0, Sx * A0 + Sy, Cn};
        float rn[3];
        if (!(*iter_centralSP)->coordinates(dn, rn))
          continue;
 
        // Bottom  point
        //
        float B0 = 2. * (Vb - A0 * Ub);
        float Cb = 1. - B0 * data.Y[b];
        float Sb = A0 + B0 * data.X[b];
        float db[3] = {Sx * Cb - Sy * Sb, Sx * Sb + Sy * Cb, Cn};
        float rb[3];
        if (!data.ITkSP[b]->coordinates(db, rb))
          continue;
 
        // Top     point
        //
        float Ct = 1. - B0 * data.Y[t];
        float St = A0 + B0 * data.X[t];
        float dt[3] = {Sx * Ct - Sy * St, Sx * St + Sy * Ct, Cn};
        float rt[3];
        if (!data.ITkSP[t]->coordinates(dt, rt))
          continue;
 
        float xb = rb[0] - rn[0];
        float yb = rb[1] - rn[1];
        float zb = rb[2] - rn[2];
        float xt = rt[0] - rn[0];
        float yt = rt[1] - rn[1];
        float zt = rt[2] - rn[2];
 
        float rb2 = 1. / (xb * xb + yb * yb);
        float rt2 = 1. / (xt * xt + yt * yt);
 
        float tb = -zb * std::sqrt(rb2);
        float tz = zt * std::sqrt(rt2);


        float meanOneOverTanTheta = (tb + tz) / 2.;

        float sigmaSquaredSpacePointErrors = Erb + data.Er[t]                                                    
                                             + 2 * Rb2z * data.R[t]                                              
                                             + 2 * Rb2r * data.R[t] * meanOneOverTanTheta * meanOneOverTanTheta; // mixed term with r-uncertainy on central SP

        float remainingSquaredDelta = (tb - tz) * (tb - tz) - sigmaSquaredSpacePointErrors;

        if (remainingSquaredDelta - sigmaSquaredScatteringMinPt > 0)
          continue;
 
        float Rn = std::sqrt(rn[0] * rn[0] + rn[1] * rn[1]);
        float Ax = rn[0] / Rn;
        float Ay = rn[1] / Rn;
 
        float ub = (xb * Ax + yb * Ay) * rb2;
        float vb = (yb * Ax - xb * Ay) * rb2;
        float ut = (xt * Ax + yt * Ay) * rt2;
        float vt = (yt * Ax - xt * Ay) * rt2;
 
        float dU = ut - ub;
        if (dU == 0.)
          continue;
        float A = (vt - vb) / dU;
        float onePlusAsquare = 1. + A * A;
        float B = vb - A * ub;
        float BSquare = B * B;

        if (BSquare > ipt2K * onePlusAsquare || remainingSquaredDelta * onePlusAsquare > BSquare * sigmaSquaredScatteringPtDependent)
          continue;

        float d0 = std::abs((A - B * Rn) * Rn);

        if (d0 <= d0max)
        {
          float dr = std::sqrt(1 / rb2);
          if (data.R[t] < data.R[b])
            dr = std::sqrt(1 / rt2);
          data.ITkSP[t]->setScorePenalty(std::abs((tb - tz) / (dr * sTzb2)));
          data.ITkSP[t]->setParam(d0);
          float DR = std::sqrt( xt * xt + yt * yt + zt * zt ); // distance between top and central SP
          data.ITkSP[t]->setDR(DR);

          data.ITkCmSp.emplace_back(B / std::sqrt(onePlusAsquare), data.ITkSP[t]);
          if (data.ITkCmSp.size() == 500)
            break;
        }
 
      } 
      if (!data.ITkCmSp.empty())
      {
        newOneSeedWithCurvaturesComparisonSSS(data, data.ITkSP[b], (*iter_centralSP), Zob);
      }
    } 
    fillSeeds(data);
    nseed += data.fillOneSeeds;
 
  } 
}

production3SpTrigger()

void ITk::SiSpacePointsSeedMaker::production3SpTrigger ( EventData & , std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & , std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & , std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & , std::array< std::vector< SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & , const int , const int , int &  ) const

private

as above, but for the trigger

Definition at line 2546 of file ITkSiSpacePointsSeedMaker.cxx.

{
   ATH_MSG_WARNING("ITk::SiSpacePointsSeedMaker::production3SpTrigger not implemented!");
}

sort()

void ITk::SiSpacePointsSeedMaker::sort ( std::vector< InDet::FloatInt > & s, int start, int size ) const

inlineprivate

Definition at line 535 of file ITkSiSpacePointsSeedMaker.h.

  {
    //QuickSort for fast tracking currently buggy
    //TBC if really faster than std::sort
    //Using std::sort in all cases for now
    std::sort(s.begin()+start,s.begin()+start+size,[](const InDet::FloatInt a, const InDet::FloatInt b)->bool {return a.Fl < b.Fl;});
  }

stripInform()

void ITk::SiSpacePointsSeedMaker::stripInform ( EventData & data, const Trk::SpacePoint * sp, float * r )

staticprivate

Definition at line 1363 of file ITkSiSpacePointsSeedMaker.cxx.

{
  const InDet::SiCluster *c0 = static_cast<const InDet::SiCluster *>(sp->clusterList().first);
  const InDet::SiCluster *c1 = static_cast<const InDet::SiCluster *>(sp->clusterList().second);
  const InDetDD::SiDetectorElement *d0 = c0->detectorElement();
  const InDetDD::SiDetectorElement *d1 = c1->detectorElement();
 
  Amg::Vector2D lc0 = c0->localPosition();
  Amg::Vector2D lc1 = c1->localPosition();
 
  std::pair<Amg::Vector3D, Amg::Vector3D> e0 =
      (d0->endsOfStrip(InDetDD::SiLocalPosition(lc0.y(), lc0.x(), 0.)));
  std::pair<Amg::Vector3D, Amg::Vector3D> e1 =
      (d1->endsOfStrip(InDetDD::SiLocalPosition(lc1.y(), lc1.x(), 0.)));
 
  Amg::Vector3D s0(.5 * (e0.first + e0.second));
  Amg::Vector3D s1(.5 * (e1.first + e1.second));
 
  Amg::Vector3D b0(.5 * (e0.second - e0.first));
  Amg::Vector3D b1(.5 * (e1.second - e1.first));
  Amg::Vector3D d02(s0 - s1);
 
  // b0
  r[3] = float(b0[0]);
  r[4] = float(b0[1]);
  r[5] = float(b0[2]);
 
  // b1
  r[6] = float(b1[0]);
  r[7] = float(b1[1]);
  r[8] = float(b1[2]);
 
  // r0-r2
  r[9] = float(d02[0]);
  r[10] = float(d02[1]);
  r[11] = float(d02[2]);
 
  // r0
  r[12] = float(s0[0]) - data.xbeam[0];
  r[13] = float(s0[1]) - data.ybeam[0];
  r[14] = float(s0[2]) - data.zbeam[0];
}

writeNtuple()

void ITk::SiSpacePointsSeedMaker::writeNtuple ( const InDet::SiSpacePointsSeed * seed, const Trk::Track * track, int seedType, long eventNumber ) const

overridevirtual

Definition at line 3377 of file ITkSiSpacePointsSeedMaker.cxx.

{
  if(m_writeNtuple) {
    std::lock_guard<std::mutex> lock(m_mutex);
 
    if(track != nullptr) {
      m_trackPt = (track->trackParameters()->front()->pT())/1000.f;
      m_trackEta = std::abs(track->trackParameters()->front()->eta());
    }
    else {
      m_trackPt = -1.;
      m_trackEta = -1.; 
    }
    m_d0           =   seed->d0();
    m_z0           =   seed->zVertex();
    m_eta          =   seed->eta();
    m_x1           =   seed->x1();
    m_x2           =   seed->x2();
    m_x3           =   seed->x3();
    m_y1           =   seed->y1();
    m_y2           =   seed->y2();
    m_y3           =   seed->y3();      
    m_z1           =   seed->z1();
    m_z2           =   seed->z2();
    m_z3           =   seed->z3();
    m_r1           =   seed->r1();
    m_r2           =   seed->r2();
    m_r3           =   seed->r3();
    m_type         =   seedType;
    m_dzdr_b       =   seed->dzdr_b();
    m_dzdr_t       =   seed->dzdr_t();
    m_pt           =   seed->pt();
    m_givesTrack   =   !(track == nullptr);
    m_eventNumber  =   eventNumber;
 
    // Ok: protected by mutex.
    TTree* outputTree ATLAS_THREAD_SAFE = m_outputTree;
    outputTree->Fill();
 
  }
 
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/24]

long m_eventNumber ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 286 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [2/24]

float m_trackEta ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 285 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [3/24]

float m_trackPt ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 284 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [4/24]

bool m_givesTrack ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 283 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [5/24]

double m_dzdr_b ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 282 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [6/24]

double m_dzdr_t ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 281 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [7/24]

int m_type ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 280 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [8/24]

float m_quality ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 279 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [9/24]

double m_r3 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 278 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [10/24]

double m_r2 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 277 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [11/24]

double m_r1 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 276 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [12/24]

double m_z3 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 275 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [13/24]

double m_z2 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 274 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [14/24]

double m_z1 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 273 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [15/24]

double m_y3 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 272 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [16/24]

double m_y2 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 271 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [17/24]

double m_y1 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 270 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [18/24]

double m_x3 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 269 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [19/24]

double m_x2 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 268 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [20/24]

double m_x1 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 267 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [21/24]

float m_eta ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 266 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [22/24]

float m_pt ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 265 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [23/24]

float m_z0 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 264 of file ITkSiSpacePointsSeedMaker.h.

ATLAS_THREAD_SAFE [24/24]

float m_d0 ITk::SiSpacePointsSeedMaker::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 263 of file ITkSiSpacePointsSeedMaker.h.

m_alwaysKeepConfirmedPixelSeeds

BooleanProperty ITk::SiSpacePointsSeedMaker::m_alwaysKeepConfirmedPixelSeeds {this, "alwaysKeepConfirmedPixelSeeds", false}

private

Definition at line 204 of file ITkSiSpacePointsSeedMaker.h.

{this, "alwaysKeepConfirmedPixelSeeds", false};

m_alwaysKeepConfirmedStripSeeds

BooleanProperty ITk::SiSpacePointsSeedMaker::m_alwaysKeepConfirmedStripSeeds {this, "alwaysKeepConfirmedStripSeeds", false}

private

Definition at line 205 of file ITkSiSpacePointsSeedMaker.h.

{this, "alwaysKeepConfirmedStripSeeds", false};

m_beamSpotKey

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

private

Definition at line 171 of file ITkSiSpacePointsSeedMaker.h.

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

m_binSizeR

FloatProperty ITk::SiSpacePointsSeedMaker::m_binSizeR {this, "radStep", 2.}

private

Definition at line 194 of file ITkSiSpacePointsSeedMaker.h.

{this, "radStep", 2.};

m_checketa

BooleanProperty ITk::SiSpacePointsSeedMaker::m_checketa {this, "checkEta", false}

private

Definition at line 235 of file ITkSiSpacePointsSeedMaker.h.

{this, "checkEta", false};

m_COF

float ITk::SiSpacePointsSeedMaker::m_COF {134 * .05f * 9}

private

Definition at line 246 of file ITkSiSpacePointsSeedMaker.h.

{134 * .05f * 9};

m_dImpactCutSlopeUnconfirmedPPP

FloatProperty ITk::SiSpacePointsSeedMaker::m_dImpactCutSlopeUnconfirmedPPP {this, "dImpactCutSlopeUnconfirmedPPP", 0.}

private

Definition at line 220 of file ITkSiSpacePointsSeedMaker.h.

{this, "dImpactCutSlopeUnconfirmedPPP", 0.};

m_dImpactCutSlopeUnconfirmedSSS

FloatProperty ITk::SiSpacePointsSeedMaker::m_dImpactCutSlopeUnconfirmedSSS {this, "dImpactCutSlopeUnconfirmedSSS", 1.0}

private

Definition at line 219 of file ITkSiSpacePointsSeedMaker.h.

{this, "dImpactCutSlopeUnconfirmedSSS", 1.0};

m_drmax

FloatProperty ITk::SiSpacePointsSeedMaker::m_drmax {this, "maxdRadius", 300.}

private

Definition at line 190 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxdRadius", 300.};

m_drmaxPPP

FloatProperty ITk::SiSpacePointsSeedMaker::m_drmaxPPP {this, "maxdRadiusPPP", 150.}

private

Definition at line 214 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxdRadiusPPP", 150.};

m_drmaxSSS

FloatProperty ITk::SiSpacePointsSeedMaker::m_drmaxSSS {this, "maxdRadiusSSS", 300.}

private

Definition at line 217 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxdRadiusSSS", 300.};

m_drmin

FloatProperty ITk::SiSpacePointsSeedMaker::m_drmin {this, "mindRadius", 5.}

private

Definition at line 189 of file ITkSiSpacePointsSeedMaker.h.

{this, "mindRadius", 5.};

m_drminPPP

FloatProperty ITk::SiSpacePointsSeedMaker::m_drminPPP {this, "mindRadiusPPP", 6.}

private

Definition at line 213 of file ITkSiSpacePointsSeedMaker.h.

{this, "mindRadiusPPP", 6.};

m_drminSeedConf

float ITk::SiSpacePointsSeedMaker::m_drminSeedConf {5.}

private

Definition at line 251 of file ITkSiSpacePointsSeedMaker.h.

{5.};

m_drminSSS

FloatProperty ITk::SiSpacePointsSeedMaker::m_drminSSS {this, "mindRadiusSSS", 20.}

private

Definition at line 216 of file ITkSiSpacePointsSeedMaker.h.

{this, "mindRadiusSSS", 20.};

m_dzdrmax0

float ITk::SiSpacePointsSeedMaker::m_dzdrmax0 {0.}

private

Definition at line 243 of file ITkSiSpacePointsSeedMaker.h.

{0.};

m_dzdrmin0

float ITk::SiSpacePointsSeedMaker::m_dzdrmin0 {0.}

private

Definition at line 242 of file ITkSiSpacePointsSeedMaker.h.

{0.};

m_dzdrver

FloatProperty ITk::SiSpacePointsSeedMaker::m_dzdrver {this, "maxdZdRver", 0.02}

private

Definition at line 196 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxdZdRver", 0.02};

m_dzMaxFast

float ITk::SiSpacePointsSeedMaker::m_dzMaxFast {200.}

private

Definition at line 247 of file ITkSiSpacePointsSeedMaker.h.

{200.};

m_dzmaxPPP

FloatProperty ITk::SiSpacePointsSeedMaker::m_dzmaxPPP {this, "dZmaxForPPPSeeds", 600.}

private

Definition at line 199 of file ITkSiSpacePointsSeedMaker.h.

{this, "dZmaxForPPPSeeds", 600.};

m_dzmaxSSS

float ITk::SiSpacePointsSeedMaker::m_dzmaxSSS {900.}

private

Definition at line 250 of file ITkSiSpacePointsSeedMaker.h.

{900.};    

m_dzver

FloatProperty ITk::SiSpacePointsSeedMaker::m_dzver {this, "maxdZver", 5.}

private

Definition at line 195 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxdZver", 5.};

m_etamax

FloatProperty ITk::SiSpacePointsSeedMaker::m_etamax {this, "etaMax", 2.7}

private

Definition at line 184 of file ITkSiSpacePointsSeedMaker.h.

{this, "etaMax", 2.7};

m_etamin

FloatProperty ITk::SiSpacePointsSeedMaker::m_etamin {this, "etaMin", 0.}

private

Definition at line 227 of file ITkSiSpacePointsSeedMaker.h.

{this, "etaMin", 0.};

m_fastTracking

BooleanProperty ITk::SiSpacePointsSeedMaker::m_fastTracking {this, "useFastTracking", false}

private

Definition at line 206 of file ITkSiSpacePointsSeedMaker.h.

{this, "useFastTracking", false};

m_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> ITk::SiSpacePointsSeedMaker::m_fieldCondObjInputKey

private

Initial value:

{this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                           "Name of the Magnetic Field conditions object key"}

Definition at line 172 of file ITkSiSpacePointsSeedMaker.h.

                                                                       {this, "AtlasFieldCacheCondObj", "fieldCondObj",
                                                                           "Name of the Magnetic Field conditions object key"};

m_inverseBinSizePhiPPP

float ITk::SiSpacePointsSeedMaker::m_inverseBinSizePhiPPP {0}

private

cache the inverse bin size in phi which we use - needed to evaluate phi bin locations

Definition at line 293 of file ITkSiSpacePointsSeedMaker.h.

{0};   

m_inverseBinSizePhiSSS

float ITk::SiSpacePointsSeedMaker::m_inverseBinSizePhiSSS {0}

private

Definition at line 295 of file ITkSiSpacePointsSeedMaker.h.

{0};

m_inverseBinSizePhiVertex

float ITk::SiSpacePointsSeedMaker::m_inverseBinSizePhiVertex {0}

private

Definition at line 297 of file ITkSiSpacePointsSeedMaker.h.

{0};

m_ipt

float ITk::SiSpacePointsSeedMaker::m_ipt {0.}

private

Definition at line 244 of file ITkSiSpacePointsSeedMaker.h.

{0.};

m_ipt2

float ITk::SiSpacePointsSeedMaker::m_ipt2 {0.}

private

Definition at line 245 of file ITkSiSpacePointsSeedMaker.h.

{0.};

m_isLRT

BooleanProperty ITk::SiSpacePointsSeedMaker::m_isLRT {this, "isLRT", false}

private

Definition at line 212 of file ITkSiSpacePointsSeedMaker.h.

{this, "isLRT", false};

m_maxBinPhiVertex

int ITk::SiSpacePointsSeedMaker::m_maxBinPhiVertex {0}

private

Definition at line 296 of file ITkSiSpacePointsSeedMaker.h.

{0};

m_maxdImpact

FloatProperty ITk::SiSpacePointsSeedMaker::m_maxdImpact {this, "maxdImpact", 10.}

private

Definition at line 197 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxdImpact", 10.};

m_maxdImpactSSS

FloatProperty ITk::SiSpacePointsSeedMaker::m_maxdImpactSSS {this, "maxdImpactSSS", 20.}

private

Definition at line 198 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxdImpactSSS", 20.};

m_maxOneSize

IntegerProperty ITk::SiSpacePointsSeedMaker::m_maxOneSize {this, "maxSeedsForSpacePoint", 5}

private

Definition at line 183 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxSeedsForSpacePoint", 5};

m_maxOneSizePPP

IntegerProperty ITk::SiSpacePointsSeedMaker::m_maxOneSizePPP {this, "maxSeedsForSpacePointPixels", 5}

private

Definition at line 203 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxSeedsForSpacePointPixels", 5};

m_maxOneSizeSSS

IntegerProperty ITk::SiSpacePointsSeedMaker::m_maxOneSizeSSS {this, "maxSeedsForSpacePointStrips", 5}

private

Definition at line 202 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxSeedsForSpacePointStrips", 5};

m_maxPhiBinPPP

int ITk::SiSpacePointsSeedMaker::m_maxPhiBinPPP {0}

private

number of bins in phi

Definition at line 292 of file ITkSiSpacePointsSeedMaker.h.

{0};           

m_maxPhiBinSSS

int ITk::SiSpacePointsSeedMaker::m_maxPhiBinSSS {0}

private

Definition at line 294 of file ITkSiSpacePointsSeedMaker.h.

{0};

m_maxScore

FloatProperty ITk::SiSpacePointsSeedMaker::m_maxScore {this, "maximumAcceptedSeedScore", 100.}

private

Definition at line 201 of file ITkSiSpacePointsSeedMaker.h.

{this, "maximumAcceptedSeedScore", 100.};

m_maxsize

IntegerProperty ITk::SiSpacePointsSeedMaker::m_maxsize {this, "maxSize", 10000}

private

Definition at line 181 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxSize", 10000};

m_maxsizeSP

IntegerProperty ITk::SiSpacePointsSeedMaker::m_maxsizeSP {this, "maxSizeSP", 4096}

private

Definition at line 182 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxSizeSP", 4096};

m_mutex

std::mutex ITk::SiSpacePointsSeedMaker::m_mutex

mutableprivate

Definition at line 260 of file ITkSiSpacePointsSeedMaker.h.

m_nBinsR

int ITk::SiSpacePointsSeedMaker::m_nBinsR {0}

private

number of bins in the radial coordinate

Definition at line 291 of file ITkSiSpacePointsSeedMaker.h.

{0};              

m_neighbourCellsBottomPPP

std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> ITk::SiSpacePointsSeedMaker::m_neighbourCellsBottomPPP {}

private

mapping of neighbour cells in the 2D phi-z binning to consider for the "bottom SP" search for central SPs in each phi-z bin. Number of valid entries stored in m_nNeighboursPhiZbottom

Definition at line 315 of file ITkSiSpacePointsSeedMaker.h.

{}; 

m_neighbourCellsBottomSSS

std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> ITk::SiSpacePointsSeedMaker::m_neighbourCellsBottomSSS {}

private

Definition at line 320 of file ITkSiSpacePointsSeedMaker.h.

{};

m_neighbourCellsTopPPP

std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> ITk::SiSpacePointsSeedMaker::m_neighbourCellsTopPPP {}

private

mapping of neighbour cells in the 2D phi-z binning to consider for the "top SP" search for central SPs in each phi-z bin. Number of valid entries stored in m_nNeighboursPhiZtop

Definition at line 316 of file ITkSiSpacePointsSeedMaker.h.

{}; 

m_neighbourCellsTopSSS

std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> ITk::SiSpacePointsSeedMaker::m_neighbourCellsTopSSS {}

private

Definition at line 321 of file ITkSiSpacePointsSeedMaker.h.

{};

m_neighboursVertexPhiZ

std::array<std::array<int, arraySizeNeighbourBinsVertex>, arraySizePhiZV> ITk::SiSpacePointsSeedMaker::m_neighboursVertexPhiZ {}

private

Definition at line 324 of file ITkSiSpacePointsSeedMaker.h.

{};

m_nNeighbourCellsBottomPPP

std::array<int,arraySizePhiZ> ITk::SiSpacePointsSeedMaker::m_nNeighbourCellsBottomPPP {}

private

arrays associating bins to each other for SP formation

number of neighbouring phi-z bins to consider when looking for "bottom SP" candidates for each phi-z bin

Definition at line 313 of file ITkSiSpacePointsSeedMaker.h.

{};  

m_nNeighbourCellsBottomSSS

std::array<int,arraySizePhiZ> ITk::SiSpacePointsSeedMaker::m_nNeighbourCellsBottomSSS {}

private

Definition at line 318 of file ITkSiSpacePointsSeedMaker.h.

{};

m_nNeighbourCellsTopPPP

std::array<int,arraySizePhiZ> ITk::SiSpacePointsSeedMaker::m_nNeighbourCellsTopPPP {}

private

number of neighbouring phi-z bins to consider when looking for "top SP" candidates for each phi-z bin

Definition at line 314 of file ITkSiSpacePointsSeedMaker.h.

{};  

m_nNeighbourCellsTopSSS

std::array<int,arraySizePhiZ> ITk::SiSpacePointsSeedMaker::m_nNeighbourCellsTopSSS {}

private

Definition at line 319 of file ITkSiSpacePointsSeedMaker.h.

{};

m_nNeighboursVertexPhiZ

std::array<int,arraySizePhiZV> ITk::SiSpacePointsSeedMaker::m_nNeighboursVertexPhiZ {}

private

Definition at line 323 of file ITkSiSpacePointsSeedMaker.h.

{};

m_optimisePhiBinning

BooleanProperty ITk::SiSpacePointsSeedMaker::m_optimisePhiBinning {this, "optimisePhiBinning", true}

private

Definition at line 209 of file ITkSiSpacePointsSeedMaker.h.

{this, "optimisePhiBinning", true};

m_outputlevel

int ITk::SiSpacePointsSeedMaker::m_outputlevel {0}

private

Definition at line 240 of file ITkSiSpacePointsSeedMaker.h.

{0};

m_outputTree

TTree* ITk::SiSpacePointsSeedMaker::m_outputTree

private

Definition at line 259 of file ITkSiSpacePointsSeedMaker.h.

m_pixel

BooleanProperty ITk::SiSpacePointsSeedMaker::m_pixel {this, "usePixel", true}

private

Definition at line 178 of file ITkSiSpacePointsSeedMaker.h.

{this, "usePixel", true};

m_prdToTrackMap

SG::ReadHandleKey<Trk::PRDtoTrackMap> ITk::SiSpacePointsSeedMaker::m_prdToTrackMap {this,"PRDtoTrackMap","","option PRD-to-track association"}

private

Definition at line 170 of file ITkSiSpacePointsSeedMaker.h.

{this,"PRDtoTrackMap","","option PRD-to-track association"};

m_ptmin

FloatProperty ITk::SiSpacePointsSeedMaker::m_ptmin {this, "pTmin", 500.}

private

Definition at line 229 of file ITkSiSpacePointsSeedMaker.h.

{this, "pTmin", 500.};

m_r1maxv

FloatProperty ITk::SiSpacePointsSeedMaker::m_r1maxv {this, "maxVRadius1", 60.}

private

Definition at line 186 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxVRadius1", 60.};

m_r1minv

FloatProperty ITk::SiSpacePointsSeedMaker::m_r1minv {this, "minVRadius1", 0.}

private

Definition at line 185 of file ITkSiSpacePointsSeedMaker.h.

{this, "minVRadius1", 0.};

m_R2MaxFast

float ITk::SiSpacePointsSeedMaker::m_R2MaxFast {2025}

private

Definition at line 248 of file ITkSiSpacePointsSeedMaker.h.

{2025}; // 45mm*45mm. Updated for ITK Layout 03-00-00

m_r2maxv

FloatProperty ITk::SiSpacePointsSeedMaker::m_r2maxv {this, "maxVRadius2", 200.}

private

Definition at line 188 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxVRadius2", 200.};

m_r2minv

FloatProperty ITk::SiSpacePointsSeedMaker::m_r2minv {this, "minVRadius2", 70.}

private

Definition at line 187 of file ITkSiSpacePointsSeedMaker.h.

{this, "minVRadius2", 70.};

m_r_rmax

FloatProperty ITk::SiSpacePointsSeedMaker::m_r_rmax {this, "radMax", 1100.}

private

Definition at line 228 of file ITkSiSpacePointsSeedMaker.h.

{this, "radMax", 1100.};

m_r_rmin

FloatProperty ITk::SiSpacePointsSeedMaker::m_r_rmin {this, "radMin", 0.}

private

Definition at line 193 of file ITkSiSpacePointsSeedMaker.h.

{this, "radMin", 0.};

m_rmaxPPP

float ITk::SiSpacePointsSeedMaker::m_rmaxPPP {140.}

private

Definition at line 249 of file ITkSiSpacePointsSeedMaker.h.

{140.};

m_rmaxSSS

FloatProperty ITk::SiSpacePointsSeedMaker::m_rmaxSSS {this, "radMaxSSS", 1000.}

private

Definition at line 211 of file ITkSiSpacePointsSeedMaker.h.

{this, "radMaxSSS", 1000.};

m_rminSSS

FloatProperty ITk::SiSpacePointsSeedMaker::m_rminSSS {this, "radMinSSS", 400.}

private

Definition at line 210 of file ITkSiSpacePointsSeedMaker.h.

{this, "radMinSSS", 400.};

m_seedScoreBonusConfirmationSeed

FloatProperty ITk::SiSpacePointsSeedMaker::m_seedScoreBonusConfirmationSeed {this, "seedScoreBonusConfirmationSeed", -200.}

private

Definition at line 221 of file ITkSiSpacePointsSeedMaker.h.

{this, "seedScoreBonusConfirmationSeed", -200.};

m_seedScoreBonusPPP

FloatProperty ITk::SiSpacePointsSeedMaker::m_seedScoreBonusPPP {this, "seedScoreBonusPPP", -200.}

private

Definition at line 207 of file ITkSiSpacePointsSeedMaker.h.

{this, "seedScoreBonusPPP", -200.};

m_seedScoreBonusSSS

FloatProperty ITk::SiSpacePointsSeedMaker::m_seedScoreBonusSSS {this, "seedScoreBonusSSS", -400.}

private

Definition at line 208 of file ITkSiSpacePointsSeedMaker.h.

{this, "seedScoreBonusSSS", -400.};

m_seedScoreThresholdPPPConfirmationSeed

float ITk::SiSpacePointsSeedMaker::m_seedScoreThresholdPPPConfirmationSeed {0.}

private

Seed score thresholds defined based on the modifiers defined as configurables above.

These allow to categorise the seeds based on their quality score. The modifiers above are much larger than the range of the raw unmodified scores would be, resulting in a grouping of the scores based on the modifiers applied. The thresholds are just below the value reachable without the additional modifier max (score is assigned negative sign) score for PPP seeds with confirmation seed requirement.

Definition at line 308 of file ITkSiSpacePointsSeedMaker.h.

{0.};    

m_seedScoreThresholdSSSConfirmationSeed

float ITk::SiSpacePointsSeedMaker::m_seedScoreThresholdSSSConfirmationSeed {0.}

private

max (score is assigned negative sign) score for SSS seeds with confirmation seed requirement.

Definition at line 309 of file ITkSiSpacePointsSeedMaker.h.

{0.};    

m_spacepointsOverlap

SG::ReadHandleKey<SpacePointOverlapCollection> ITk::SiSpacePointsSeedMaker::m_spacepointsOverlap {this, "SpacePointsOverlapName", "OverlapSpacePoints"}

private

Definition at line 169 of file ITkSiSpacePointsSeedMaker.h.

{this, "SpacePointsOverlapName", "OverlapSpacePoints"};

m_spacepointsPixel

SG::ReadHandleKey<SpacePointContainer> ITk::SiSpacePointsSeedMaker::m_spacepointsPixel {this, "SpacePointsPixelName", "ITkPixelSpacePoints", "Pixel space points container"}

private

Definition at line 168 of file ITkSiSpacePointsSeedMaker.h.

{this, "SpacePointsPixelName", "ITkPixelSpacePoints", "Pixel space points container"};

m_spacepointsStrip

SG::ReadHandleKey<SpacePointContainer> ITk::SiSpacePointsSeedMaker::m_spacepointsStrip {this, "SpacePointsStripName", "ITkStripSpacePoints", "Strip space points container"}

private

Definition at line 167 of file ITkSiSpacePointsSeedMaker.h.

{this, "SpacePointsStripName", "ITkStripSpacePoints", "Strip space points container"};

m_strip

BooleanProperty ITk::SiSpacePointsSeedMaker::m_strip {this, "useStrip", true}

private

Definition at line 179 of file ITkSiSpacePointsSeedMaker.h.

{this, "useStrip", true};

m_thistSvc

ServiceHandle<ITHistSvc> ITk::SiSpacePointsSeedMaker::m_thistSvc

private

Flag to write validation ntuples. Turned off by default.

Definition at line 258 of file ITkSiSpacePointsSeedMaker.h.

m_treeFolder

std::string ITk::SiSpacePointsSeedMaker::m_treeFolder

private

Definition at line 262 of file ITkSiSpacePointsSeedMaker.h.

m_treeName

std::string ITk::SiSpacePointsSeedMaker::m_treeName

private

Definition at line 261 of file ITkSiSpacePointsSeedMaker.h.

m_umax

FloatProperty ITk::SiSpacePointsSeedMaker::m_umax {this, "minSeedsQuality", 0.}

private

Definition at line 230 of file ITkSiSpacePointsSeedMaker.h.

{this, "minSeedsQuality", 0.};

m_useOverlap

BooleanProperty ITk::SiSpacePointsSeedMaker::m_useOverlap {this, "useOverlapSpCollection", true}

private

Definition at line 180 of file ITkSiSpacePointsSeedMaker.h.

{this, "useOverlapSpCollection", true};

m_useSeedConfirmation

BooleanProperty ITk::SiSpacePointsSeedMaker::m_useSeedConfirmation {this, "useSeedConfirmation", false}

private

Definition at line 222 of file ITkSiSpacePointsSeedMaker.h.

{this, "useSeedConfirmation", false};

m_writeNtuple

Gaudi::Property<bool> ITk::SiSpacePointsSeedMaker::m_writeNtuple {this, "WriteNtuple", false, "Flag to write Validation Ntuples"}

private

Definition at line 256 of file ITkSiSpacePointsSeedMaker.h.

{this, "WriteNtuple", false, "Flag to write Validation Ntuples"};

m_zmax

FloatProperty ITk::SiSpacePointsSeedMaker::m_zmax {this , "maxZ", +250.}

private

Definition at line 192 of file ITkSiSpacePointsSeedMaker.h.

{this , "maxZ", +250.};

m_zmaxPPP

FloatProperty ITk::SiSpacePointsSeedMaker::m_zmaxPPP {this, "maxZPPP", 2700.}

private

Definition at line 215 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxZPPP", 2700.};

m_zmaxSSS

FloatProperty ITk::SiSpacePointsSeedMaker::m_zmaxSSS {this, "maxZSSS", 2700.}

private

Definition at line 218 of file ITkSiSpacePointsSeedMaker.h.

{this, "maxZSSS", 2700.};

m_zmin

FloatProperty ITk::SiSpacePointsSeedMaker::m_zmin {this, "minZ", -250.}

private

Definition at line 191 of file ITkSiSpacePointsSeedMaker.h.

{this, "minZ", -250.};

---

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

• ITkSiSpacePointsSeedMaker.h
• ITkSiSpacePointsSeedMaker.cxx