InDet::SiSpacePointsSeedMaker_ATLxk Class Reference

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

#include <SiSpacePointsSeedMaker_ATLxk.h>

Inheritance diagram for InDet::SiSpacePointsSeedMaker_ATLxk:

Public Member Functions
Standard tool methods
	SiSpacePointsSeedMaker_ATLxk (const std::string &, const std::string &, const IInterface *)
	Constructor.
virtual	~SiSpacePointsSeedMaker_ATLxk ()=default
virtual StatusCode	initialize () override
	Initialisation.
virtual StatusCode	finalize () override
	Finalize.
Methods to initialize tool for new event or region
virtual void	newEvent (const EventContext &ctx, EventData &data, int iteration) const override
	Initialize tool for new event.
virtual void	newRegion (const EventContext &ctx, EventData &data, const std::vector< IdentifierHash > &vPixel, const std::vector< IdentifierHash > &vSCT) const override
	Initialize tool for new region.
virtual void	newRegion (const EventContext &ctx, SiSpacePointsSeedMakerEventData &data, const std::vector< IdentifierHash > &vPixel, const std::vector< IdentifierHash > &vSCT, 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 SiSpacePointsSeed *	next (const EventContext &ctx, EventData &data) const override
	This method will update the data.seedOutput member to be the next seed pointed at by the data.i_seed_Pro iterator over the data.l_seeds_Pro list.
virtual void	writeNtuple (const SiSpacePointsSeed *seed, const Trk::Track *track, int seedType, long eventNumber) const override
	This method is called by the SiSPSeededTrackFinder algorithm to fill ntuples for seeds seen by the algorithm.
virtual bool	getWriteNtupleBoolProperty () const override

Private Attributes
FloatProperty	m_maxScore {this, "maximumAcceptedSeedScore", 100.}
	Maximum score to accept.
std::array< int, arraySizePhiZ >	m_nNeighbourCellsBottom {}
	arrays associating bins to each other for SP formation
std::array< int, arraySizePhiZ >	m_nNeighbourCellsTop {}
	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_neighbourCellsBottom {}
	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_neighbourCellsTop {}
	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, arraySizePhiZV >	m_nNeighboursVertexPhiZ {}
std::array< std::array< int, arraySizeNeighbourBinsVertex >, arraySizePhiZV >	m_neighboursVertexPhiZ {}
Data handles
Private data and methods
SG::ReadHandleKey< SpacePointContainer >	m_spacepointsPixel {this, "SpacePointsPixelName", "PixelSpacePoints", "Pixel space points container"}
SG::ReadHandleKey< SpacePointContainer >	m_spacepointsSCT {this, "SpacePointsSCTName", "SCT_SpacePoints", "SCT 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
	Read handle for conditions object to get the field cache.
Properties, which will not be changed after construction
BooleanProperty	m_pixel {this, "usePixel", true}
BooleanProperty	m_sct {this, "useSCT", true}
BooleanProperty	m_useOverlap {this, "useOverlapSpCollection", true}
IntegerProperty	m_maxsize {this, "maxSize", 50000}
IntegerProperty	m_maxsizeSP {this, "maxSizeSP", 5000}
IntegerProperty	m_maxOneSizeSSS {this, "maxSeedsForSpacePointStrips", 5}
	maximum number of seeds to keep per central space point.
IntegerProperty	m_maxOneSizePPP {this, "maxSeedsForSpacePointPixels", 5}
BooleanProperty	m_alwaysKeepConfirmedPixelSeeds {this, "alwaysKeepConfirmedPixelSeeds", false}
	This flag will lead to all confirmed seeds (seeds where a second compatible seed with a different top spacepoint is found) being kept, even in excess of maxSeedsForSpacePoint above.
BooleanProperty	m_alwaysKeepConfirmedStripSeeds {this, "alwaysKeepConfirmedStripSeeds", false}
BooleanProperty	m_optimisePhiBinning {this, "optimisePhiBinning", true}
	This flag will make the buildFrameWork method determine an optimal phi binning of the search regions based on the pt and IP cuts, assuming PPP and/or SSS passes are being run.
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_drmax {this, "maxdRadius", 270.}
FloatProperty	m_zmin {this, "minZ", -250.}
FloatProperty	m_zmax {this, "maxZ", +250.}
FloatProperty	m_dzver {this, "maxdZver", 5.}
FloatProperty	m_dzdrver {this, "maxdZdRver", .02}
Properties, which can be updated in buildFrameWork method which is called in initialize method
FloatProperty	m_etamin {this, "etaMin", 0.}
FloatProperty	m_r_rmax {this, "radMax", 600.}
FloatProperty	m_binSizeR {this, "radStep", 2.}
FloatProperty	m_drmin {this, "mindRadius", 5.}
FloatProperty	m_maxdImpact {this, "maxdImpact", 10.}
FloatProperty	m_maxdImpactSSS {this, "maxdImpactSSS", 50.}
FloatProperty	m_dImpactCutSlopeUnconfirmedSSS {this, "dImpactCutSlopeUnconfirmedSSS", 1.0}
	these flags allow to dynamically tighten the d0 cut on non-confirmed seeds based on the penalty score they receive for kinking in the r-z plane.
FloatProperty	m_dImpactCutSlopeUnconfirmedPPP {this, "dImpactCutSlopeUnconfirmedPPP", 0.}
FloatProperty	m_maxdImpactDecays {this, "maxdImpactForDecays", 20.}
FloatProperty	m_ptmin {this, "pTmin", 500.}
FloatProperty	m_fieldScale {this, "fieldScale", 1.}
Properties, which can be updated in newEvent method. checketa is prepared in EventData.
BooleanProperty	m_checketa {this, "checkEta", false}
FloatProperty	m_seedScoreBonusPPP {this, "seedScoreBonusPPP", -200.}
	Scoring modifiers applied when ranking seeds.
FloatProperty	m_seedScoreBonusSSS {this, "seedScoreBonusSSS", -400.}
FloatProperty	m_seedScoreBonusConfirmationSeed {this, "seedScoreBonusConfirmationSeed", -200.}
Data member, which is not updated at all.
float	m_drminv {20.}
Binning parameters
int	m_nBinsR {0}
	number of bins in the radial coordinate
int	m_maxPhiBin {0}
	number of bins in phi
int	m_maxBinPhiVertex {0}
	number of bins in phi for vertices
float	m_inverseBinSizePhi {0}
	cache the inverse bin size in phi which we use - needed to evaluate phi bin locations
float	m_inverseBinSizePhiVertex {0}
	as above but for vertex
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.

Static Private Attributes
static constexpr float	m_radiusCutIBL {43.}
	We detect IBL hits via the seed radial location.

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
	Dumps relevant information into the MsgStream.

Data members, which are updated only in buildFrameWork in initialize
float	m_dzdrmin0 {0.}
	conversion factors and cached cut values
float	m_dzdrmax0 {0.}
	implicitly store eta cut
float	m_ipt {0.}
	inverse of 90% of the ptmin cut
float	m_ipt2 {0.}
	inverse square of 90% of the pt min cut
static constexpr float	m_COF {134*.05f*9}
	appears to be an approximated term related to multiple-scattering of particles traversing the ID during the seed formation

Disallow default instantiation, copy, assignment
Gaudi::Property< bool >	m_writeNtuple {this, "WriteNtuple", false, "Flag to write Validation Ntuples"}
	Flag to write validation ntuples. Turned off by default.
ServiceHandle< ITHistSvc >	m_thistSvc
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
	SiSpacePointsSeedMaker_ATLxk ()=delete
	SiSpacePointsSeedMaker_ATLxk (const SiSpacePointsSeedMaker_ATLxk &)=delete
SiSpacePointsSeedMaker_ATLxk &	operator= (const SiSpacePointsSeedMaker_ATLxk &)=delete
MsgStream &	dumpConditions (EventData &data, MsgStream &out) const
	Dumps conditions information into the MsgStream.
void	buildFrameWork ()
	prepare several data members with cached cut values, conversion factors, binnings, etc
void	buildBeamFrameWork (EventData &data) const
	Initiate beam frame work for seed generator.
SiSpacePointForSeed *	newSpacePoint (EventData &data, const Trk::SpacePoint *const &sp) const
	Create a SiSpacePointForSeed from the space point.
void	newOneSeed (EventData &data, SiSpacePointForSeed *&p1, SiSpacePointForSeed *&p2, SiSpacePointForSeed *&p3, float z, float quality) const
	This inserts a seed into the set of saved seeds.
void	newOneSeedWithCurvaturesComparison (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	fillSeeds (EventData &data) const
	fills the seeds from the mapOneSeeds_Pro member into the l_seeds_Pro member of the data object, applying some more quality requirements on the way.
void	fillLists (EventData &data) const
	this method populates the data object's "histograms" (implemented as nested vectors).
void	production2Sp (EventData &data) const
void	production3Sp (EventData &data) const
	Top-level method for 3-SP seed production.
void	production3Sp (EventData &data, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_bottomCands, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_endBottomCands, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_topCands, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &iter_endTopCands, const int numberBottomCells, const int numberTopCells, int &nseed, const int zbin=-1) const
	: Seed production from space points.
void	production3SpTrigger (EventData &data, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &rb, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &rbe, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &rt, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > &rte, const int numberBottomCells, const int numberTopCells, int &nseed) const
	as above, but for the trigger
bool	newVertices (EventData &data, const std::list< Trk::Vertex > &lV) const
	This method updates the EventData based on the passed list of vertices.
void	findNext (EventData &data) const
	This method is called within next() when we are out of vertices.
bool	isZCompatible (EventData &data, const float Zv, const float R, const float T) const
bool	isUsed (const Trk::SpacePoint *sp, const Trk::PRDtoTrackMap &prd_to_track_map) const
void	initializeEventData (EventData &data) const
bool	isConfirmedSeed (const InDet::SiSpacePointForSeed *bottomSP, const InDet::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.
static MsgStream &	dumpEvent (EventData &data, MsgStream &out)
	Dumps event information into the MsgStream.
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 *&p1, SiSpacePointForSeed *&p2, float z)
static void	erase (EventData &data)
static void	convertToBeamFrameWork (EventData &data, const Trk::SpacePoint *const &sp, std::array< float, 3 > &r)
	This method popualtes the r array with the space point's coordinates relative to the beam spot.

Detailed Description

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

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

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

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

Definition at line 59 of file SiSpacePointsSeedMaker_ATLxk.h.

Member Enumeration Documentation

Size

enum InDet::SiSpacePointsSeedMaker_ATLxk::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 148 of file SiSpacePointsSeedMaker_ATLxk.h.

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

Constructor & Destructor Documentation

SiSpacePointsSeedMaker_ATLxk() [1/3]

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

Constructor.

Definition at line 32 of file SiSpacePointsSeedMaker_ATLxk.cxx.

  : base_class(t, n, p),
    m_thistSvc("THistSvc", n),
    m_outputTree(nullptr),
    m_treeName(""),
    m_treeFolder("/valNtuples/")
{
}

~SiSpacePointsSeedMaker_ATLxk()

virtual InDet::SiSpacePointsSeedMaker_ATLxk::~SiSpacePointsSeedMaker_ATLxk ( )

virtualdefault

SiSpacePointsSeedMaker_ATLxk() [2/3]

InDet::SiSpacePointsSeedMaker_ATLxk::SiSpacePointsSeedMaker_ATLxk ( )

privatedelete

SiSpacePointsSeedMaker_ATLxk() [3/3]

InDet::SiSpacePointsSeedMaker_ATLxk::SiSpacePointsSeedMaker_ATLxk ( const SiSpacePointsSeedMaker_ATLxk & )

privatedelete

Member Function Documentation

azimuthalStep()

float InDet::SiSpacePointsSeedMaker_ATLxk::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 1341 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  // Tell clang to optimize assuming that FP exceptions can trap.
  // Otherwise, it can vectorize the division, which can lead to
  // spurious division-by-zero traps from unused vector lanes.
  CXXUTILS_TRAPPING_FP;

  float Rm = pTmin/.6f;

  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.f,Rmax/(2.f*Rm))) -
                      std::asin(std::min(1.f,Rmin/(2.f*Rm))));
  return sI+sF; 
}

buildBeamFrameWork()

void InDet::SiSpacePointsSeedMaker_ATLxk::buildBeamFrameWork ( EventData & data ) const

private

Initiate beam frame work for seed generator.

Definition at line 1172 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{ 
  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
 
  const Amg::Vector3D &bsCentre = 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>(bsCentre.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>(bsCentre.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>(bsCentre.z());
  data.zbeam[1] = static_cast<float>(sinTheta*cosPhi);
  data.zbeam[2] = static_cast<float>(sinTheta*sinPhi);
  data.zbeam[3] = static_cast<float>(cosTheta);
}

buildFrameWork()

void InDet::SiSpacePointsSeedMaker_ATLxk::buildFrameWork ( )

private

prepare several data members with cached cut values, conversion factors, binnings, etc

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

the minumum allowed phi-granularity is the one we would need to reconstruct 100 MeV tracks. The approximate formula below estimates the maximum curvature we expect in a 2T magnetic field, assuming we want to contain all Si hits from our track in the phi slice we are looking at

• very conservative indeed, as we never need SCT and PIX at the same time!
  

< 1.67, bin size 0.6

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)

The factor 3 we divide by is motivated by the fact that we combine sets of three consecutive phi bins in the seed making step. So each individual bin should be approximately a third of the maximum expected azimutal deflection

case 2: SSS seeds, if we use them

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

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

pick the larger of the two and invert

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

Build radius-azimuthal-Z sorted containers for Z-vertices same logic as for the space points above

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

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 908 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  // Tell clang to optimize assuming that FP operations may trap.
  CXXUTILS_TRAPPING_FP;
 
  m_ptmin = std::max( std::abs(m_ptmin), float(100.*m_fieldScale));
  if (m_maxdImpactSSS < m_maxdImpact   ) m_maxdImpactSSS = m_maxdImpact;
  if (m_maxdImpactDecays < m_maxdImpactSSS) m_maxdImpactDecays = m_maxdImpactSSS;

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

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

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


  constexpr float twoPi = 2.f*M_PI;

  const int   nPhiBinsMax = arraySizePhi;
  const float inverseSizePhiMax = static_cast<float>(nPhiBinsMax)/twoPi; 

  constexpr float inverseSizePhiMin = 100./60.;     

  
  if (m_optimisePhiBinning){
    constexpr float radiusPixelStart = 33.; 
    constexpr float radiusPixelEnd = 150.;  
    const float binSizePhi_PPP = m_pixel ? azimuthalStep(m_ptmin/m_fieldScale,m_maxdImpact,radiusPixelStart,radiusPixelEnd)/3.f : 0.f; 
    constexpr float radiusSctStart = 295.; ; 
    constexpr float radiusSctEnd = 560.; 
    const float binSizePhi_SSS = m_sct ? azimuthalStep(m_ptmin/m_fieldScale,m_maxdImpactSSS,radiusSctStart,radiusSctEnd)/3.f : 0.f; 
    m_inverseBinSizePhi = 1.f/std::max(binSizePhi_PPP, binSizePhi_SSS); 
  }
  else {
    float ptm = 400.; 
    if (m_ptmin/m_fieldScale < ptm) ptm = m_ptmin/m_fieldScale;
    m_inverseBinSizePhi = ptm /60.f;
  }

  if      (m_inverseBinSizePhi > inverseSizePhiMax) m_inverseBinSizePhi = inverseSizePhiMax;
  else if (m_inverseBinSizePhi < inverseSizePhiMin) m_inverseBinSizePhi = inverseSizePhiMin;

  m_maxPhiBin = static_cast<int>(twoPi*m_inverseBinSizePhi);
  if (m_maxPhiBin >=nPhiBinsMax) m_maxPhiBin = nPhiBinsMax-1;

  const int   nPhiBinsVertexMax  = arraySizePhiV;
  const float inverseBinSizePhiVertexMax = static_cast<float>(nPhiBinsVertexMax)/twoPi;
  m_inverseBinSizePhiVertex = m_ptmin/m_fieldScale/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;
 

 
  for (int phiBin=0; phiBin<=m_maxPhiBin; ++phiBin) {
 
    int phiBelow = phiBin-1;
    if (phiBelow<0) phiBelow=m_maxPhiBin; 
 
    int phiAbove = phiBin+1;
    if (phiAbove>m_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;
 
      m_nNeighbourCellsBottom [twoDbinSamePhi]    = 3; 
      m_nNeighbourCellsTop [twoDbinSamePhi]    = 3;
 
      m_neighbourCellsBottom[twoDbinSamePhi][0] = twoDbinSamePhi; 
      m_neighbourCellsTop[twoDbinSamePhi][0] = twoDbinSamePhi;
 
      m_neighbourCellsBottom[twoDbinSamePhi][1] = twoDbinLowerPhi; 
      m_neighbourCellsTop[twoDbinSamePhi][1] = twoDbinLowerPhi;
 
      m_neighbourCellsBottom[twoDbinSamePhi][2] = twoDbinHigherPhi; 
      m_neighbourCellsTop[twoDbinSamePhi][2] = twoDbinHigherPhi;

      if (z==5) {
        m_nNeighbourCellsTop [twoDbinSamePhi]    = 9;
        // in the central z region, we include the two neighbouring 
        // z slices for the top neighbour search   
 
        m_neighbourCellsTop[twoDbinSamePhi][3] = twoDbinSamePhi+1;
        m_neighbourCellsTop[twoDbinSamePhi][4] = twoDbinLowerPhi+1;
        m_neighbourCellsTop[twoDbinSamePhi][5] = twoDbinHigherPhi+1;
        m_neighbourCellsTop[twoDbinSamePhi][6] = twoDbinSamePhi-1;
        m_neighbourCellsTop[twoDbinSamePhi][7] = twoDbinLowerPhi-1;
        m_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 
        m_nNeighbourCellsBottom [twoDbinSamePhi]    = 6;
        m_neighbourCellsBottom[twoDbinSamePhi][3] = twoDbinSamePhi-1;
        m_neighbourCellsBottom[twoDbinSamePhi][4] = twoDbinLowerPhi-1;
        m_neighbourCellsBottom[twoDbinSamePhi][5] = twoDbinHigherPhi-1;
 
        if (z<10) {
          m_nNeighbourCellsTop [twoDbinSamePhi]    = 6;
          m_neighbourCellsTop[twoDbinSamePhi][3] = twoDbinSamePhi+1;
          m_neighbourCellsTop[twoDbinSamePhi][4] = twoDbinLowerPhi+1;
          m_neighbourCellsTop[twoDbinSamePhi][5] = twoDbinHigherPhi+1;
        }
      } 
      // z < 5: negative z values, |z| > 250mm 
      else {
        m_nNeighbourCellsBottom [twoDbinSamePhi]    = 6;
        m_neighbourCellsBottom[twoDbinSamePhi][3] = twoDbinSamePhi+1;
        m_neighbourCellsBottom[twoDbinSamePhi][4] = twoDbinLowerPhi+1;
        m_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 
          m_nNeighbourCellsTop [twoDbinSamePhi]    = 6;
          m_neighbourCellsTop[twoDbinSamePhi][3] = twoDbinSamePhi-1;
          m_neighbourCellsTop[twoDbinSamePhi][4] = twoDbinLowerPhi-1;
          m_neighbourCellsTop[twoDbinSamePhi][5] = twoDbinHigherPhi-1;
        }
      }

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

  for (int phiBin=0; phiBin<=m_maxBinPhiVertex; ++phiBin) {
 
    int phiBinBelow = phiBin-1;
    if (phiBinBelow<0) phiBinBelow=m_maxBinPhiVertex;
 
    int phiBinTop = phiBin+1;
    if (phiBinTop>m_maxBinPhiVertex) phiBinTop=0;
    
    for (int zbin=0; zbin<arraySizeZV; ++zbin) {
      
      int twoDbinSamePhi  = phiBin *arraySizeZV+zbin;
      int twoDbinLowerPhi  = phiBinBelow*arraySizeZV+zbin;
      int twoDbinHigherPhi  = phiBinTop*arraySizeZV+zbin;

      m_nNeighboursVertexPhiZ[twoDbinSamePhi]    = 3;
      m_neighboursVertexPhiZ[twoDbinSamePhi][0] = twoDbinSamePhi;
      m_neighboursVertexPhiZ[twoDbinSamePhi][1] = twoDbinLowerPhi;
      m_neighboursVertexPhiZ[twoDbinSamePhi][2] = twoDbinHigherPhi;

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

convertToBeamFrameWork()

void InDet::SiSpacePointsSeedMaker_ATLxk::convertToBeamFrameWork ( EventData & data, const Trk::SpacePoint *const & sp, std::array< float, 3 > & r )

staticprivate

This method popualtes the r array with the space point's coordinates relative to the beam spot.

Initiate beam frame work for seed generator.

Parameters

[in]	data	Event data
[in]	sp	Space point to take the global position from
[out]	r	3-array, will be populated with the relative coordinates

Definition at line 1207 of file SiSpacePointsSeedMaker_ATLxk.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 & InDet::SiSpacePointsSeedMaker_ATLxk::dump ( EventData & data, MsgStream & out ) const

overridevirtual

Dumps relevant information into the MsgStream.

Definition at line 694 of file SiSpacePointsSeedMaker_ATLxk.cxx.

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

dumpConditions()

MsgStream & InDet::SiSpacePointsSeedMaker_ATLxk::dumpConditions ( EventData & data, MsgStream & out ) const

private

Dumps conditions information into the MsgStream.

Definition at line 706 of file SiSpacePointsSeedMaker_ATLxk.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_spacepointsSCT.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<<"| SCT      space points   | "<<m_spacepointsSCT.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<<"| useSCT                  | "
     <<std::setw(12)<<m_sct 
     <<"                              |"<<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 radius first  SP(2) | "
     <<std::setw(12)<<std::setprecision(5)<<m_r1minv
     <<"                              |"<<endmsg;
  out<<"| min radius second SP(2) | "
     <<std::setw(12)<<std::setprecision(5)<<m_r2minv
     <<"                              |"<<endmsg;
  out<<"| max radius first  SP(2) | "
     <<std::setw(12)<<std::setprecision(5)<<m_r1maxv
     <<"                              |"<<endmsg;
  out<<"| max radius second SP(2) | "
     <<std::setw(12)<<std::setprecision(5)<<m_r2maxv
     <<"                              |"<<endmsg;
  out<<"| min space points dR     | "
     <<std::setw(12)<<std::setprecision(5)<<m_drmin
     <<"                              |"<<endmsg;
  out<<"| max space points dR     | "
     <<std::setw(12)<<std::setprecision(5)<<m_drmax
     <<"                              |"<<endmsg;
  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 & InDet::SiSpacePointsSeedMaker_ATLxk::dumpEvent ( EventData & data, MsgStream & out )

staticprivate

Dumps event information into the MsgStream.

Definition at line 827 of file SiSpacePointsSeedMaker_ATLxk.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.l_seeds_Pro.size()
     <<"                              |"<<endmsg;
  out<<"|---------------------------------------------------------------------|"
     <<endmsg;
  return out;
}

erase()

void InDet::SiSpacePointsSeedMaker_ATLxk::erase ( EventData & data )

staticprivate

Definition at line 1374 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  for (int i=0; i<data.nrfz;  ++i) {
    int n = data.rfz_index[i];
    data.rfz_map[n] = 0;
    data.rfz_Sorted[n].clear();
  }
  
  for (int i=0; i<data.nrfzv; ++i) {
    int n = data.rfzv_index[i];
    data.rfzv_map[n] = 0;
    data.rfzv_Sorted[n].clear();
  }
  data.state = 0;
  data.nsaz  = 0;
  data.nsazv = 0;
  data.nrfz  = 0;
  data.nrfzv = 0;
}

fillLists()

void InDet::SiSpacePointsSeedMaker_ATLxk::fillLists ( EventData & data ) const

private

this method populates the data object's "histograms" (implemented as nested vectors).

Initiate space points seed maker.

using the list of r-binned space points in the object assumed to have been previously set (for example via the newEvent method of this class).

Parameters

[in,out]

data

Event data which will be updated.

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

if we are in the second iteration (PPP pass), we have some special exit conditions.

if we are dealing with a pixel hit and the radial bin index is below 20, we are in the IBL. this seems to be based on the default radial step of 2mm / bin, where this is equivalent to 40mm.

if we reach a strip hit in the PPP pass, we have two conditions for bailing out:

a) if we saw IBL hits in the past, we stop as soon as we see the first strip hit - pure PPP

b) in case we did not see any IBL hits, we stop after bin index 175. using the default r bin size of 2mm, this is equivalent to 350mm. So the idea seems to be to include the first strip layer at 299mm before we stop. This implies that for the non-IBL running, we include PPS seeds in this pass.

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)

if we do not use the SCT, and did see some hits somewhere below 43mm (meaning we have the IBL installed), apply stricter requirements on the seed score later on

Definition at line 1219 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  constexpr float twoPi = 2.*M_PI;
 
  int  firstRadialBin =     0;
  bool ibl = false;
 
  
    const std::map<float, int> ztoBin{
      {-2500.    ,0},
      {-1400.    ,1},
      {-925.     ,2},
      {-450.     ,3},
      {-250      ,4},
      { 250      ,5},
      { 450      ,6},
      { 925      ,7},
      { 1400     ,8},
      { 2500     ,9},
      { 100000   ,10},  
    };
 
  for (int radialBin=data.r_first; radialBin<m_nBinsR;  ++radialBin) {

    if (!data.r_map[radialBin]) continue;
    if (firstRadialBin == 0) firstRadialBin = radialBin;

    if (data.iteration) {
      if (!data.r_Sorted[radialBin].front()->spacepoint->clusterList().second) {
        if (radialBin * m_binSizeR < m_radiusCutIBL) ibl = true;
      } 


      else if (ibl) {
        break;
      } 
      else if (radialBin > 175) {
        break;
      }
    }
    // loop over the space points in the r-bin and sort them into the 2d phi-z binning 
    for (InDet::SiSpacePointForSeed* SP : data.r_Sorted[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*m_inverseBinSizePhi);
      if (phiBin < 0) {
        phiBin = m_maxPhiBin;
      } else if (phiBin > m_maxPhiBin) {
        phiBin = 0;
      }
 
      float Z = SP->z();
      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_Sorted[twoDbin].push_back(SP);
      if (!data.rfz_map[twoDbin]++) data.rfz_index[data.nrfz++] = twoDbin;
    }
  }
  if (!m_sct && firstRadialBin && static_cast<float>(firstRadialBin)*m_binSizeR < m_radiusCutIBL) {
    data.maxScore = m_seedScoreThresholdPPPConfirmationSeed;
  }
 
  data.state = 0;
}

fillSeeds()

void InDet::SiSpacePointsSeedMaker_ATLxk::fillSeeds ( EventData & data ) const

private

fills the seeds from the mapOneSeeds_Pro member into the l_seeds_Pro member of the data object, applying some more quality requirements on the way.

Fill seeds.

Parameters

[in,out]

data

Event data which is modified

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

if this is not the highest-quality seed in the list and we have the first hit in the IBL, require a confirmation seed (score is then boosted by -200 for PPP + -200 for confirmation --> below -200)

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 2402 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
 
  data.fillOneSeeds = 0;
 
  std::multimap<float,InDet::SiSpacePointsProSeed*>::iterator it_firstSeedCandidate = data.mapOneSeeds_Pro.begin();
  std::multimap<float,InDet::SiSpacePointsProSeed*>::iterator it_seedCandidate  = data.mapOneSeeds_Pro.begin();
  std::multimap<float,InDet::SiSpacePointsProSeed*>::iterator it_endSeedCandidates = data.mapOneSeeds_Pro.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 (it_seedCandidate!=it_firstSeedCandidate && theSeed->spacepoint0()->radius() < m_radiusCutIBL && quality > m_seedScoreThresholdPPPConfirmationSeed) continue;
    if (!theSeed->setQuality(quality)) continue;
    
    if (data.i_seede_Pro!=data.l_seeds_Pro.end()) {
      theSeed  = &(*data.i_seede_Pro++);
      *theSeed = *(*it_seedCandidate).second;
    } else {
      data.l_seeds_Pro.emplace_back(*(*it_seedCandidate).second);
      //unused value, keep commented to avoid repetition
      //theSeed = &(data.l_seeds_Pro.back());
      data.i_seede_Pro = data.l_seeds_Pro.end();
    }
    
   ++data.fillOneSeeds;
  } 
}

finalize()

StatusCode InDet::SiSpacePointsSeedMaker_ATLxk::finalize ( )

overridevirtual

Finalize.

Definition at line 122 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  return AlgTool::finalize();
}

find2Sp()

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

overridevirtual

With two space points with or without vertex constraint.

Methods to initilize different strategies of seeds production with two space points with or without vertex constraint.

Definition at line 530 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  if (not data.initialized) initializeEventData(data);
 
  data.zminU = m_zmin;
  data.zmaxU = m_zmax;
 
  int mode = 0;
  if (lv.begin()!=lv.end()) mode = 1;
  bool newv = newVertices(data, lv);
  
  if (newv || !data.state || data.nspoint!=2 || data.mode!=mode || data.nlist) {
    data.i_seede_Pro = data.l_seeds_Pro.begin();
    data.state = 1;
    data.nspoint = 2;
    data.nlist = 0;
    data.mode = mode;
    data.endlist = true;
    data.fvNmin = 0;
    data.fNmin = 0;
    data.zMin = 0;
    production2Sp(data);
  }
  data.i_seed_Pro = data.l_seeds_Pro.begin();
  
 
  if (msgLvl(MSG::DEBUG)) {
    data.nprint=1;
    dump(data, msg(MSG::DEBUG));
  }
}

find3Sp() [1/2]

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

overridevirtual

with three space points with or without vertex constraint

Methods to initilize different strategies of seeds production with three space points with or without vertex constraint.

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_seed_Pro iterator - this is used to return the seeds to the consumer when they call next()

Definition at line 567 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  if (not data.initialized) initializeEventData(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_seede_Pro = data.l_seeds_Pro.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_seed_Pro = data.l_seeds_Pro.begin();
 
  
  if (msgLvl(MSG::DEBUG)) {
    data.nprint=1;
    dump(data, msg(MSG::DEBUG));
  }
}

find3Sp() [2/2]

void InDet::SiSpacePointsSeedMaker_ATLxk::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

Methods to initilize different strategies of seeds production with three space points with or without vertex constraint.

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_seed_Pro iterator - this is used to return the seeds to the consumer when they call next()

Definition at line 611 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  if (not data.initialized) initializeEventData(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_seede_Pro = data.l_seeds_Pro.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_seed_Pro = data.l_seeds_Pro.begin();
 
  if (msgLvl(MSG::DEBUG)) {  
    data.nprint=1;
    dump(data, msg(MSG::DEBUG));
  }
}

findNext()

void InDet::SiSpacePointsSeedMaker_ATLxk::findNext ( EventData & data ) const

private

This method is called within next() when we are out of vertices.

Find next set space points.

It will internally trigger a re-run of production3Sp if we are out of seeds and data.endlist is not set (indicating the search is not finished).

Definition at line 852 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  if (data.endlist) return;
 
  data.i_seede_Pro = data.l_seeds_Pro.begin();
 
  if      (data.mode==0 or data.mode==1) production2Sp(data);
  else if (data.mode==2 or data.mode==3) production3Sp(data);
  else if (data.mode==5 or data.mode==6) production3Sp(data);
 
  data.i_seed_Pro = data.l_seeds_Pro.begin();
  ++data.nlist;
}                       

findVSp()

void InDet::SiSpacePointsSeedMaker_ATLxk::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

Methods to initilize different strategies of seeds production with variable number space points with or without vertex constraint Variable means (2,3,4,....) any number space points.

Definition at line 659 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  if (not data.initialized) initializeEventData(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_seede_Pro = data.l_seeds_Pro.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_seed_Pro = data.l_seeds_Pro.begin();
 
  if (msgLvl(MSG::DEBUG)) { 
    data.nprint=1;
    dump(data, msg(MSG::DEBUG));
  }
}

getWriteNtupleBoolProperty()

bool InDet::SiSpacePointsSeedMaker_ATLxk::getWriteNtupleBoolProperty ( ) const

overridevirtual

Definition at line 2632 of file SiSpacePointsSeedMaker_ATLxk.cxx.

                                                                        {
    return m_writeNtuple;
} 

initialize()

StatusCode InDet::SiSpacePointsSeedMaker_ATLxk::initialize ( )

overridevirtual

Initialisation.

Get beam geometry

PRD-to-track association (optional)

Build framework. Will set up internal variables not related to the event data object

Definition at line 46 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  StatusCode sc = AlgTool::initialize();
 
  ATH_CHECK(m_spacepointsPixel.initialize(m_pixel));
  ATH_CHECK(m_spacepointsSCT.initialize(m_sct));
  ATH_CHECK(m_spacepointsOverlap.initialize(m_useOverlap));

  if (not m_beamSpotKey.empty()) {
    ATH_CHECK(m_beamSpotKey.initialize());
  }
 
  ATH_CHECK( m_fieldCondObjInputKey.initialize() );

  ATH_CHECK( m_prdToTrackMap.initialize( !m_prdToTrackMap.key().empty()));
  
  buildFrameWork();
 
  if (msgLvl(MSG::DEBUG)) { 
    EventData data;
    initializeEventData(data);
    data.nprint=0;
    dump(data, msg(MSG::DEBUG));
  }
 
  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); 
    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 InDet::SiSpacePointsSeedMaker_ATLxk::initializeEventData ( EventData & data ) const

private

maxsize not used

sizeRF not used

Definition at line 2604 of file SiSpacePointsSeedMaker_ATLxk.cxx.

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

isConfirmedSeed()

bool InDet::SiSpacePointsSeedMaker_ATLxk::isConfirmedSeed ( const InDet::SiSpacePointForSeed * bottomSP, const InDet::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 2618 of file SiSpacePointsSeedMaker_ATLxk.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 InDet::SiSpacePointsSeedMaker_ATLxk::isUsed ( const Trk::SpacePoint * sp, const Trk::PRDtoTrackMap & prd_to_track_map ) const

inlineprivate

Definition at line 536 of file SiSpacePointsSeedMaker_ATLxk.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 InDet::SiSpacePointsSeedMaker_ATLxk::isZCompatible ( EventData & data, const float Zv, const float R, const float T ) const

private

Definition at line 2525 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  if (Zv < data.zminU or Zv > data.zmaxU) return false;
  if (not data.isvertex) return true;
  if (data.l_vertex.empty()) return false;
 
  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);
  //(Minor) speed-up: Avoid calculation of sqrt, compare squares
  return dZmin*dZmin < (m_dzver+m_dzdrver*R)*(m_dzver+m_dzdrver*R)*(1.f+T*T);
}

newEvent()

void InDet::SiSpacePointsSeedMaker_ATLxk::newEvent ( const EventContext & ctx, EventData & data, int iteration ) const

overridevirtual

Initialize tool for new event.

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

pass the iteration info into our data object

Erase any existing entries in the data object

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

in the first iteration, initialise the beam framework - beam spot position and direction

Read the field information

Get field cache object

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}

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

for the second iteration (PPP pass), don't redo the full init required the first time

< reset the first radial bin

call fillLists to repopulate the candidate space points and exit

the following will only happen in the first iteration

build the r-binning.

This cleans up remaining entries in the data object. In standard execution, we only run this in the first iterations on a newly created data object, in which case this loop will not ever be entered. Leaving it in place for nonstandard use cases.

read the prd to track map, in case we want to use it.

Now, we will populate the space point list in the event data object once.

reset the first r index

Get pixels space points containers from store gate

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

Remove DBM space points

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

if this is the highest bin we saw so far, update the r_first member of the data object to this bin

update the space point counter

< increment r_first past the last occupied bin we saw

Get sct space points containers from store gate

as for the pixel, veto already used SP if we are using the PRD to track map in later passes of track finding. Also, veto SP outside the maximum radius

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

as for PIX, determine the radial bin. Note that for the SCT we do not update data.r_first.

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 sct 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 radius

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.

negative iterations are not used in the current run-3 reco

populates the phi-z sorted histograms using the spacepoint lists and r-binning. after this call, we have a 3D binning

Definition at line 131 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  if (not data.initialized) initializeEventData(data);
 
  data.trigger = false;
  if (!m_pixel && !m_sct) return;

  data.iteration = iteration;
  if (iteration <=0) data.iteration = 0;
  erase(data);
  data.dzdrmin = m_dzdrmin0;
  data.dzdrmax = m_dzdrmax0;
  data.maxScore = m_maxScore;     

  if (data.iteration == 0) {
    if (not m_beamSpotKey.empty()) {
      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("SiSpacePointsSeedMaker_ATLxk: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
      return;
    }
    fieldCondObj->getInitializedCache (fieldCache);
 
    if (fieldCache.solenoidOn()) {
      fieldCache.getFieldZR(globalPos,magField);
      data.K = 2.f/(300.f*float(magField[2]));
    } else {
      data.K = 2.f/(300.f* 5.f );
    } 
    data.ipt2K = m_ipt2/(data.K*data.K);
    data.ipt2C = m_ipt2*m_COF;
    data.COFK = m_COF*(data.K*data.K);

    data.i_spforseed = data.l_spforseed.begin();
    // 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;
    
  } 
  else {  
    data.r_first = 0;     
    // 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;

    fillLists(data);
    return;
  }

 
  data.checketa = data.dzdrmin > 1.;

  float oneOverBinSizeR = 1.f/m_binSizeR;
  int   maxBinR  = m_nBinsR-1;
 
  for (int i=0; i<data.nr; ++i) {
    int n = data.r_index[i];
    data.r_map[n] = 0;
    data.r_Sorted[n].clear();
  }
  data.ns = data.nr = 0;

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


  data.r_first = 0;

  if (m_pixel) {
 
    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) continue;

          const InDetDD::SiDetectorElement* de= 
            static_cast<const InDetDD::SiDetectorElement*>(sp->clusterList().first->detectorElement());
          if (!de || de->isDBM()) continue;
 
          InDet::SiSpacePointForSeed* sps = newSpacePoint(data, sp);
          if (!sps) continue;

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

          data.r_Sorted[radiusBin].push_back(sps);
          ++data.r_map[radiusBin];
          if (data.r_map[radiusBin]==1) data.r_index[data.nr++] = radiusBin;
          if (radiusBin > data.r_first) data.r_first = radiusBin;
          ++data.ns;
        } 
      }
    } 
    ++data.r_first; 
  } 
  
  if (m_sct) {
 
    SG::ReadHandle<SpacePointContainer> spacepointsSCT{m_spacepointsSCT, ctx};
    if (spacepointsSCT.isValid()) {
 
      for (const SpacePointCollection* spc: *spacepointsSCT) {
        for (const Trk::SpacePoint* sp: *spc) {
          if ((prd_to_track_map_cptr &&  isUsed(sp,*prd_to_track_map_cptr)) || sp->r() > m_r_rmax) continue;

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

          int radiusBin = static_cast<int>(sps->radius()*oneOverBinSizeR);
          if (radiusBin>maxBinR) radiusBin = maxBinR;
          data.r_Sorted[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) continue;

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

          int radiusBin = static_cast<int>(sps->radius()*oneOverBinSizeR);
          if (radiusBin>maxBinR) radiusBin = maxBinR;
          data.r_Sorted[radiusBin].push_back(sps);
          ++data.r_map[radiusBin];
          if (data.r_map[radiusBin]==1) data.r_index[data.nr++] = radiusBin;
          ++data.ns;
        }
      }
    }
  }
  
  if (iteration < 0) data.r_first = 0;

  fillLists(data);
}

newOneSeed()

void InDet::SiSpacePointsSeedMaker_ATLxk::newOneSeed ( EventData & data, InDet::SiSpacePointForSeed *& p1, InDet::SiSpacePointForSeed *& p2, InDet::SiSpacePointForSeed *& p3, float z, float quality ) const

private

This inserts a seed into the set of saved seeds.

It internally respects the user-configured max number of seeds per central space point. Once this is exceeded, the new seed will replace worse-quality seeds if there are any, otherwise it will not insert anything.

Parameters

[in,out]	data	Event data - update OneSeeds_Pro and mapOneSeeds_Pro members
[in]	p1	First space point for this seed
[in]	p2	Second space point for this seed
[in]	p3	Third space point for this seed
[in]	z	z0 IP estimate
[in]	quality	quality estimate (based on d0, plus modifiers)

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 2216 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  float worstQualityInMap = std::numeric_limits<float>::min();
  InDet::SiSpacePointsProSeed* worstSeedSoFar = nullptr;
  if (!data.mapOneSeeds_Pro.empty()) {
    std::multimap<float,InDet::SiSpacePointsProSeed*>::reverse_iterator l = data.mapOneSeeds_Pro.rbegin();
    worstQualityInMap = (*l).first;
    worstSeedSoFar = (*l).second;
  }
  if (data.nOneSeeds < data.maxSeedsPerSP
      || (data.keepAllConfirmedSeeds  && worstQualityInMap <= seedCandidateQuality  && isConfirmedSeed(p1,p3,seedCandidateQuality) && data.nOneSeeds < data.seedPerSpCapacity)
      || (data.keepAllConfirmedSeeds  && worstQualityInMap >  seedCandidateQuality  && worstSeedSoFar
      && isConfirmedSeed(worstSeedSoFar->spacepoint0(),worstSeedSoFar->spacepoint2(),worstQualityInMap) && data.nOneSeeds < data.seedPerSpCapacity)
    ){
    data.OneSeeds_Pro[data.nOneSeeds].set(p1,p2,p3,z);
    data.mapOneSeeds_Pro.insert(std::make_pair(seedCandidateQuality, &data.OneSeeds_Pro[data.nOneSeeds]));
    ++data.nOneSeeds;
  } 
  else if (worstSeedSoFar && (worstQualityInMap > seedCandidateQuality)){
      worstSeedSoFar->set(p1,p2,p3,z);
      std::multimap<float,InDet::SiSpacePointsProSeed*>::iterator 
        i = data.mapOneSeeds_Pro.insert(std::make_pair(seedCandidateQuality,worstSeedSoFar));
      for (++i; i!=data.mapOneSeeds_Pro.end(); ++i) {
        if ((*i).second==worstSeedSoFar) {
          data.mapOneSeeds_Pro.erase(i);
          return;
        }
      }
  }
}

newOneSeedWithCurvaturesComparison()

void InDet::SiSpacePointsSeedMaker_ATLxk::newOneSeedWithCurvaturesComparison ( 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,out]	data	Event data, used to read top SP candidates and write out found seeds (see newOneSeed).
[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

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 2273 of file SiSpacePointsSeedMaker_ATLxk.cxx.

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

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

  for (; it_commonTopSP!=ie; ++it_commonTopSP) {

    float seedIP   = (*it_commonTopSP).second->param();
    float seedQuality    = seedIP + (*it_commonTopSP).second->scorePenalty();
    float originalSeedQuality   = seedQuality;
 
    if(m_maxdImpact > 50){      //This only applies to LRT
      // Tell clang to optimize assuming that FP exceptions can trap.
      // Otherwise, it can vectorize the division, which can lead to
      // spurious division-by-zero traps from unused vector lanes.
      CXXUTILS_TRAPPING_FP;
 
      float topR=(*it_commonTopSP).second->radius();
      float topZ=(*it_commonTopSP).second->z();
 
      float Zot = std::abs(topR - bottomR) > 10e-9 ?
        bottomZ - (bottomR - originalSeedQuality) * ((topZ - bottomZ) / (topR - bottomR)) : bottomZ;
 
      float eta1 = computeEta(topR - bottomR, topZ - bottomZ);
      float eta0 = computeEta(seedIP, Zot);
 
      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.5f,originalSeedQuality/200.f);  //0.5 and 200 are parameters chosen from a grid scan to optimize efficiency
      seedQuality*=(1.f-f)/300.f;
      seedQuality+=f*deltaEta/2.5f;
    }
 
    bool                topSPisPixel = !(*it_commonTopSP).second->spacepoint->clusterList().second;
    
    const Trk::Surface* surfaceTopSP  = (*it_commonTopSP).second->sur   ();
    float               radiusTopSP   = (*it_commonTopSP).second->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_drmin) 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 > (*it_commonTopSP).second->quality()) 
      ) continue;
    }
    if (!isConfirmedSeed(SPb,it_commonTopSP->second,seedQuality)){
      double                maxdImpact = m_maxdImpact    - (m_dImpactCutSlopeUnconfirmedPPP * (*it_commonTopSP).second->scorePenalty()); 
      if (!bottomSPisPixel) maxdImpact = m_maxdImpactSSS - (m_dImpactCutSlopeUnconfirmedSSS * (*it_commonTopSP).second->scorePenalty()); 
      if (seedIP > maxdImpact) continue; 
    }
    newOneSeed(data, SPb, SP0, (*it_commonTopSP).second, Zob, seedQuality);
  } 
  data.CmSp.clear();
}

newRegion() [1/2]

void InDet::SiSpacePointsSeedMaker_ATLxk::newRegion ( const EventContext & ctx, EventData & data, const std::vector< IdentifierHash > & vPixel, const std::vector< IdentifierHash > & vSCT ) const

overridevirtual

Initialize tool for new region.

not used in offline reco (trigger specific)

Definition at line 378 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  if (not data.initialized) initializeEventData(data);
 
  data.iteration  = 0;
  data.trigger = false;
  erase(data);
  if (!m_pixel && !m_sct) return;
 
  data.dzdrmin = m_dzdrmin0;
  data.dzdrmax = m_dzdrmax0;
  data.maxScore = m_maxScore;
 
  if (not m_beamSpotKey.empty()) {
    buildBeamFrameWork(data);
  }
 
  double magField[3]{0,0,0};
  double globalPos[3] ={10.,10.,0.};
 
  MagField::AtlasFieldCache    fieldCache;
  // Get field cache object
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx};
  const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
  
  if (fieldCondObj == nullptr) {
    ATH_MSG_ERROR("SiSpacePointsSeedMaker_ATLxk: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key());
    return;
  }
  fieldCondObj->getInitializedCache (fieldCache);
 
  // initialise pt cuts and conversion factors 
  if (fieldCache.solenoidOn()) {
    fieldCache.getFieldZR(globalPos,magField);
 
    data.K = 2.f/(300.f*float(magField[2]));
  } else {
    data.K = 2.f/(300.f* 5.f );
  }
 
  data.ipt2K = m_ipt2/(data.K*data.K);
  data.ipt2C = m_ipt2*m_COF;
  data.COFK = m_COF*(data.K*data.K);
 
  data.i_spforseed = data.l_spforseed.begin();
 
  float oneOverBinSizeR = 1.f/m_binSizeR;
  int   maxBinR  = m_nBinsR-1;
 
  data.r_first = 0;
  data.checketa = false;
 
  for (int i=0; i<data.nr; ++i) {
    int n = data.r_index[i];
    data.r_map[n] = 0;
    data.r_Sorted[n].clear();
  }
  data.ns = data.nr = 0;
 
  // Get pixels space points containers from store gate 
  //
  if (m_pixel && !vPixel.empty()) {
 
    SG::ReadHandle<SpacePointContainer> spacepointsPixel{m_spacepointsPixel, ctx};
    if ( spacepointsPixel.isValid() ) {
 
      // 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 (r > m_r_rmax) continue;
          InDet::SiSpacePointForSeed* sps = newSpacePoint(data, sp);
          int ir = static_cast<int>(sps->radius()*oneOverBinSizeR);
          if (ir>maxBinR) ir = maxBinR;
          data.r_Sorted[ir].push_back(sps);
          ++data.r_map[ir];
          if (data.r_map[ir]==1) data.r_index[data.nr++] = ir;
          ++data.ns;
        }
      }
    }
  }
 
  // Get sct space points containers from store gate 
  //
  if (m_sct && !vSCT.empty()) {
 
    SG::ReadHandle<SpacePointContainer> spacepointsSCT{m_spacepointsSCT, ctx};
    if (spacepointsSCT.isValid()) {
 
      // Loop through all trigger collections
      //
      for (const IdentifierHash& l: vSCT) {
        const auto *w = spacepointsSCT->indexFindPtr(l);
        if (w==nullptr) continue;
        for (const Trk::SpacePoint* sp: *w) {
          float r = sp->r();
          if (r > m_r_rmax) continue;
          InDet::SiSpacePointForSeed* sps = newSpacePoint(data, sp);
          int ir = static_cast<int>(sps->radius()*oneOverBinSizeR);
          if (ir>maxBinR) ir = maxBinR;
          data.r_Sorted[ir].push_back(sps);
          ++data.r_map[ir];
          if (data.r_map[ir]==1) data.r_index[data.nr++] = ir;
          ++data.ns;
        }
      }
    }
  }
  fillLists(data);
}

newRegion() [2/2]

virtual void InDet::SiSpacePointsSeedMaker_ATLxk::newRegion ( const EventContext & ctx, SiSpacePointsSeedMakerEventData & data, const std::vector< IdentifierHash > & vPixel, const std::vector< IdentifierHash > & vSCT, const IRoiDescriptor & iRD ) const

overridevirtual

newSeed()

void InDet::SiSpacePointsSeedMaker_ATLxk::newSeed ( EventData & data, InDet::SiSpacePointForSeed *& p1, InDet::SiSpacePointForSeed *& p2, float z )

staticprivate

Definition at line 2590 of file SiSpacePointsSeedMaker_ATLxk.cxx.

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

newSpacePoint()

InDet::SiSpacePointForSeed * InDet::SiSpacePointsSeedMaker_ATLxk::newSpacePoint ( EventData & data, const Trk::SpacePoint *const & sp ) const

private

Create a SiSpacePointForSeed from the space point.

New space point for seeds.

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.

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 2548 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  InDet::SiSpacePointForSeed* sps = nullptr;

  std::array<float,3> r{0,0,0};
  convertToBeamFrameWork(data, sp, r);

  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 (data.i_spforseed!=data.l_spforseed.end()) {
    sps = &(*data.i_spforseed++);
    sps->set(sp,r);
  } else {
    data.l_spforseed.emplace_back(sp, r);
    sps = &(data.l_spforseed.back());
    data.i_spforseed = data.l_spforseed.end();
  }
      
  return sps;
}

newVertices()

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

private

This method updates the EventData based on the passed list of vertices.

New and old list vertices comparison.

The list may be empty. Updates the isvertex, l_vertex, zminU and zmaxU members of the data object. Always returns false.

Parameters

[in,out]	data	Event data to update
[in]	lV	possibly empty list of vertices

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.

Ich bin der Geist, der stets verneint! are we sure this is not a bug?

Definition at line 870 of file SiSpacePointsSeedMaker_ATLxk.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.f;
  if (data.zminU < m_zmin) data.zminU = m_zmin;
  data.zmaxU = (*data.l_vertex.rbegin())+20.f;
  if (data.zmaxU > m_zmax) data.zmaxU = m_zmax;

  return false;
}

next()

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

overridevirtual

This method will update the data.seedOutput member to be the next seed pointed at by the data.i_seed_Pro iterator over the data.l_seeds_Pro list.

Some poor quality PPS seeds will be skipped, this cut is implemented within the SiSpacePointsSeed::set3 method. If we run out of seeds after having previously reached a premature abort condition, seed finding will automatically be continued until all seeds have been found.

Parameters

[in]	ctx	Event contex
[in,out]	data	Event data, updated and used to obtain the next seed to return

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 2443 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  if (not data.initialized) initializeEventData(data);
  
  if (data.nspoint==3) {
    do {
      if (data.i_seed_Pro==data.i_seede_Pro) {
        findNext(data);
        //cppcheck-suppress identicalInnerCondition 
        if (data.i_seed_Pro==data.i_seede_Pro) return nullptr;
      }
    } while (!(*data.i_seed_Pro++).set3(data.seedOutput));

    return &data.seedOutput;
  } else {
    if (data.i_seed_Pro==data.i_seede_Pro) {
      findNext(data);
      //cppcheck-suppress identicalInnerCondition
      if (data.i_seed_Pro==data.i_seede_Pro) return nullptr;
    } 
    (*data.i_seed_Pro++).set2(data.seedOutput);
    return &data.seedOutput;
  }
  return nullptr;
}

operator=()

SiSpacePointsSeedMaker_ATLxk & InDet::SiSpacePointsSeedMaker_ATLxk::operator= ( const SiSpacePointsSeedMaker_ATLxk & )

privatedelete

production2Sp()

void InDet::SiSpacePointsSeedMaker_ATLxk::production2Sp ( EventData & data ) const

private

Definition at line 1404 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  if (data.nsazv<2) return;
 
  std::vector<InDet::SiSpacePointForSeed*>::iterator r0,r0e,r,re;
  int nseed = 0;
 
  // Loop thorugh all azimuthal regions
  //
  for (int f=data.fvNmin; f<=m_maxBinPhiVertex; ++f) {
 
    // For each azimuthal region loop through Z regions
    //
    int z = 0;
    if (!data.endlist) z = data.zMin;
    for (; z<arraySizeZV; ++z) {
      
      int a = f*arraySizeZV+z;
      if (!data.rfzv_map[a]) continue;
      r0  = data.rfzv_Sorted[a].begin();
      r0e = data.rfzv_Sorted[a].end  ();
 
      if (!data.endlist) {
        r0 = data.rMin;
        data.endlist = true;
      }
 
      // Loop through trigger space points
      //
      for (; r0!=r0e; ++r0) {
 
        float X  = (*r0)->x();
        float Y  = (*r0)->y();
        float R  = (*r0)->radius();
        if (R<m_r2minv) continue;
        if (R>m_r2maxv) break;
        float Z  = (*r0)->z();
        float ax = X/R;
        float ay = Y/R;
 
        // Bottom links production
        //
        int numberBottomCells = m_nNeighboursVertexPhiZ[a];
        for (int i=0; i<numberBottomCells; ++i) {
    
          int an = m_neighboursVertexPhiZ[a][i];
          if (!data.rfzv_map[an]) continue;
 
          r  = data.rfzv_Sorted[an].begin();
          re = data.rfzv_Sorted[an].end();
    
          for (; r!=re; ++r) {
      
            float Rb =(*r)->radius();
            if (Rb<m_r1minv) continue;
            if (Rb>m_r1maxv) break;
            float dR = R-Rb;
            if (dR<m_drminv) break;
            if (dR>m_drmax) continue;
            float dZ = Z-(*r)->z();
            float Tz = dZ/dR;
            if (Tz<data.dzdrmin || Tz>data.dzdrmax) continue;
            float Zo = Z-R*Tz;
 
            // Comparison with vertices Z coordinates
            //
            if (!isZCompatible(data, Zo, Rb, Tz)) continue;
 
            // Momentum cut
            //
            float dx =(*r)->x()-X;
            float dy =(*r)->y()-Y;
            float x  = dx*ax+dy*ay;
            float y  =-dx*ay+dy*ax;
            float xy = x*x+y*y;
            if (xy == 0.) continue;
            float r2 = 1.f/xy;
            float Ut = x*r2;
            float Vt = y*r2;
            float UR = Ut*R+1.f;
            if (UR == 0.) continue;
            float A  = Vt*R/UR;
            float B  = Vt-A*Ut;
            if (std::abs(B*data.K) > m_ipt*std::sqrt(1.f+A*A)) continue;
            ++nseed;
            newSeed(data, (*r), (*r0), Zo);
          }
        }
        if (nseed < m_maxsize) continue;
        data.endlist=false;
        data.rMin = (++r0);
        data.fvNmin=f;
        data.zMin=z;
        return;
      }
    }
  }
  data.endlist = true;
}

production3Sp() [1/2]

void InDet::SiSpacePointsSeedMaker_ATLxk::production3Sp ( EventData & data ) const

private

Top-level method for 3-SP seed production.

This method loops over each eta-Z region, and in each region calls the extended production3Sp method below to do the actual work.

Parameters

[in,out]

data

Event data which will be updated

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 So we first go from the IP to the right, then from the IP to the left, each time working our way outward

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 1508 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{

  if (data.nsaz<3) return;

 
 
  const std::array<int,arraySizeZ> zBinIndex {5,6,7,8,9,10,4,3,2,1,0};

  std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator,arraySizeNeighbourBins> iter_topCands;
  std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator,arraySizeNeighbourBins> iter_endTopCands;
  std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator,arraySizeNeighbourBins> iter_bottomCands;
  std::array<std::vector<InDet::SiSpacePointForSeed*>::iterator,arraySizeNeighbourBins> iter_endBottomCands;
  
  int    nseed =    0;
  data.endlist = true;

  for (int phiBin=data.fNmin; phiBin<=m_maxPhiBin; ++phiBin) {
    
    int z = 0;
    if (!data.endlist) z = data.zMin;

    for (; z<arraySizeZ; ++z) {
      
      int phiZbin  = phiBin *arraySizeZ+zBinIndex[z];

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

      int numberBottomCells = 0;
      int numberTopCells = 0;

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

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

      if (!data.trigger) production3Sp       (data, iter_bottomCands, iter_endBottomCands, iter_topCands, iter_endTopCands, numberBottomCells, numberTopCells, nseed,zBinIndex[z]);
      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;
}

production3Sp() [2/2]

void InDet::SiSpacePointsSeedMaker_ATLxk::production3Sp ( EventData & data, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_bottomCands, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_endBottomCands, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_topCands, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & iter_endTopCands, const int numberBottomCells, const int numberTopCells, int & nseed, const int zbin = -1 ) 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.

identify if we are looking at pixel or strip space points

bins 4,5,6 are the region in z = +/- 450 mm - "barrel like" in terms of hit locations

the central SP should not be in the IBL (nothing could go below)

in the pixels, the highest-up SP can be fairly far out along the disk

in the barrel pixels, we also remove the outermost layer from the central SP search

for strip seed formation, allow most of the strip volume

default behaviour, applies in the forward region

start slightly above the lowest r occuring in the SCT for the central SP

for the central SP, do not go all the way to the upper edge of a disk.

in the barrel avoid the first strip layer for the central SP

skip last barrel layer as well - there must be a hit beyond

in the transition also avoid the first strip layer for the central SP

here, actually go higher than otherwise, to catch the ~full extent of the first two disks. We manually exclude the flat barrel part below

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

veto the last pixel disk

veto strip barrel layer 4 in the transition region

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

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 bottom SP is too far, remember this for future iterations and don't bother starting from the beginning again

if the points are too close in r, abort (future ones will be even closer). If we are in the second pass (PPP) and starting to reach strip spacepoints, also time to stop!

dZ/dR

and abs value

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

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

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 did not find ANY bottom SP, or if we exceed the storage capacity, we abort this seed candidate.

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

Top links production

again, loop over cells of interest, this time for the top SP candidate

loop over each SP in each cell

evaluate the radial distance,

and continue if we are too close

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

evaluate (and cut on) dZ/dR

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

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 found no top candidates (remember, Nt starts counting at Nb), 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

for strips, apply the strip version of the IP cut

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

theta estimate of the seed based on the average value of 1/tan(theta)

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. 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 = V --> B = V - A x U

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

< delta U = 0 blocks the evaluation of A.

< A parameter, slope of the seed point distribution in the U,V plane

< B parameter, V axis intercept of the seed point distribution in the U,V plane

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 the precise d0 calculation if we don't have to worry about floating point exceptions

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

set parameters for ntuple writing

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 1625 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{ 

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


  bool isStrip = ((*iter_centralSP)->spacepoint->clusterList().second); 

  bool isBarrelRegion = (zbin >=4 && zbin <= 6); 
  bool isTransitionRegion = (zbin == 3 || zbin == 7);   // region in z = 450 - 925mm 
  float rmin =  40.;    
  float rmax = 140.;    
 
  if (isBarrelRegion){
    rmax = 100;   
  }
  if(isStrip) {
    rmin = 285.;    
    rmax = 450.;    
    if (isBarrelRegion){
      rmin = 335;  
      rmax = 450.; 
    }
    else if (isTransitionRegion){
      rmin = 335;  
      rmax = 550;  
    }
  }

  for(; iter_centralSP!=iter_endBottomCands[0]; ++iter_centralSP) {
    if((*iter_centralSP)->radius() > rmin) 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 maxd0cutstrips = m_maxdImpactDecays;
  const float zmin  = data.zminU;
  const float zmax  = data.zmaxU;
  const float dzdrmax = data.dzdrmax;
  const float dzdrmin = data.dzdrmin;
  data.CmSp.clear();

  size_t SPcapacity = data.SP.size(); 

  for (; iter_centralSP!=iter_endBottomCands[0]; ++iter_centralSP) {
 
    const float& R  = (*iter_centralSP)->radius();
    if(R > rmax) 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 (isStrip && absZ > 2650. ) continue;
    if (!isStrip && absZ > 600.) continue;
    if (isStrip && isTransitionRegion && absZ < 750. && R > 450.) continue; 

    size_t                 Nb   = 0;

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

        if (dR > m_drmax) {
          iter_bottomCands[cell]=iter_otherSP;
          continue;
        }
        if (dR < m_drmin || (data.iteration && (*iter_otherSP)->spacepoint->clusterList().second)) break;

        const float dZdR = (Z-(*iter_otherSP)->z())/dR;
        const float absdZdR = std::abs(dZdR);
        if (absdZdR < dzdrmin or absdZdR > dzdrmax) continue;
  
        const float z0 = Z-R*dZdR;
          if(z0 > zmax || z0 < zmin) continue;
        data.SP[Nb] = (*iter_otherSP);
        if(m_writeNtuple) data.SP[Nb]->setDZDR(dZdR);
        if (++Nb==SPcapacity){
            data.resizeSPCont();
            SPcapacity=data.SP.size();
        }
      } 
    } 

    if (!Nb) continue;

    size_t Nt = Nb;
    

    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_drmin) {
          iter_topCands[cell]=iter_otherSP;
          continue;
        }
        if (dR>m_drmax) break;

        float dZdR = ((*iter_otherSP)->z()-Z)/dR;
        float absdZdR = std::abs(dZdR);
          if (absdZdR < dzdrmin or absdZdR > dzdrmax) continue;

        float z0 = Z-R*dZdR;
          if(z0 > zmax || z0 < zmin) continue;
        data.SP[Nt] = (*iter_otherSP);
        if (m_writeNtuple)  data.SP[Nt]->setDZDR(dZdR);
        if (++Nt==SPcapacity) {
          data.resizeSPCont(); 
          SPcapacity=data.SP.size();
        }
      } 
    } 
    
    if (!(Nt-Nb)) 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<Nt; ++i) {
 
      InDet::SiSpacePointForSeed* sp = data.SP[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.f/(x*x+y*y);
      float dr  = std::sqrt(r2);
      float tz  = dz*dr;

      if (i < Nb) tz = -tz;

      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.mapOneSeeds_Pro.clear();

    for (size_t b=0; b<Nb; ++b) {
      
      float  Zob  = data.Zo[b];       
      float  Tzb  = data.Tz[b];       
      float  Erb  = data.Er[b];       
      float  Vb   = data.V [b];       
      float  Ub   = data.U [b];       
      float  Tzb2 = (1.f+Tzb*Tzb);     
      float sTzb2 = std::sqrt(Tzb2);       
      float sigmaSquaredScatteringPtDependent  = Tzb2*COFK;        
      float sigmaSquaredScatteringMinPt  = Tzb2*ipt2C;       
      float d0max  = maxd0cut;
      if (data.SP[b]->spacepoint->clusterList().second) d0max = maxd0cutstrips;

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

        
        float meanOneOverTanTheta = (Tzb+data.Tz[t])/2.f; 
        float theta = 0.;
        if(m_writeNtuple){
          theta = std::atan(1.f/meanOneOverTanTheta);
        }
        float sigmaSquaredSpacePointErrors = Erb+data.Er[t]   
                        + 2.f * covz0 * data.R[t]*data.R[b]    
                        + 2.f * covr0 * data.R[t]*data.R[b] * meanOneOverTanTheta * meanOneOverTanTheta; // mixed term with r-uncertainy on central SP
        float remainingSquaredDelta  = (Tzb-data.Tz[t])*(Tzb-data.Tz[t]) - sigmaSquaredSpacePointErrors; 

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

        if (BSquare  > ipt2K*onePlusAsquare || remainingSquaredDelta*onePlusAsquare > BSquare*sigmaSquaredScatteringPtDependent) continue;
        float d0 = 0;         
        if(std::abs(B) < 1e-10) d0  = std::abs((A-B*R)*R);  
        else{
          float x0 = -A/(2.f*B);
          float rTrack = std::sqrt(onePlusAsquare/BSquare)*.5f;
          d0 = std::abs(-rTrack + std::sqrt(rTrack*rTrack +2.f*x0*R +R*R));
        }

        if (d0 <= d0max) {
          float dr = data.R[b];
          if (data.R[t] < data.R[b]) dr = data.R[t];
          data.SP[t]->setScorePenalty(std::abs((Tzb-data.Tz[t])/(dr*sTzb2)));
          data.SP[t]->setParam(d0);
 
          if(m_writeNtuple){
            data.SP[t]->setEta(-std::log(std::tan(0.5f*theta)));
            data.SP[t]->setPt(std::sqrt(onePlusAsquare/BSquare)/(1000.f*data.K)); 
          }
          data.CmSp.emplace_back(B/std::sqrt(onePlusAsquare), data.SP[t]);
 
        }
   
      }   
      if (!data.CmSp.empty()) {
        newOneSeedWithCurvaturesComparison(data, data.SP[b], (*iter_centralSP), Zob);
      }
    } 
    fillSeeds(data);
    nseed += data.fillOneSeeds;
   
  } 
}

production3SpTrigger()

void InDet::SiSpacePointsSeedMaker_ATLxk::production3SpTrigger ( EventData & data, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & rb, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & rbe, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & rt, std::array< std::vector< InDet::SiSpacePointForSeed * >::iterator, arraySizeNeighbourBins > & rte, const int numberBottomCells, const int numberTopCells, int & nseed ) const

private

as above, but for the trigger

Definition at line 2022 of file SiSpacePointsSeedMaker_ATLxk.cxx.

{
  constexpr float twoPi = 2.*M_PI;
 
  std::vector<InDet::SiSpacePointForSeed*>::iterator r0=rb[0],r;
 
  float rmin =  40.;
  float rmax = 140.;
  if((*r0)->spacepoint->clusterList().second) {
    rmin = 280.;
    rmax = 540.;
  }
 
  for(; r0!=rbe[0]; ++r0) {if((*r0)->radius() > rmin) break;}
  rt[0] = r0; ++rt[0];
 
  float ipt2K = data.ipt2K;
  float ipt2C = data.ipt2C;
  float COFK  = data.COFK;
  float maxd0cut = m_maxdImpact;
  float maxd0cutstrips = m_maxdImpactSSS;
 
  data.CmSp.clear();
 
  // Loop through all trigger space points
  //
  for (; r0!=rbe[0]; ++r0) {
 
    data.nOneSeeds = 0;
    data.mapOneSeeds_Pro.clear();
  
    float R  = (*r0)->radius();
    if(R>rmax) break;
 
    const Trk::Surface* sur0 = (*r0)->sur();
    float               X    = (*r0)->x();
    float               Y    = (*r0)->y();
    float               Z    = (*r0)->z();
    int                 Nb   = 0;
 
    // Bottom links production
    //
    for (int i=0; i<numberBottomCells; ++i) {
 
      for (r=rb[i]; r!=rbe[i]; ++r) {
  
        float Rb =(*r)->radius();
 
        float dR = R-Rb;
        if (dR > m_drmax) {
          rb[i]=r;
          continue;
        }
        if ((*r)->sur()==sur0) continue;
 
        if (dR < m_drmin || (data.iteration && (*r)->spacepoint->clusterList().second)) break;
 
        // Comparison with  bottom and top Z 
        //
        float Tz = (Z-(*r)->z())/dR;
        float Zo = Z-R*Tz;
        if (Zo < data.zminB || Zo > data.zmaxB) continue;
        float Zu = Z+(550.f-R)*Tz;
        if (Zu < data.zminU || Zu > data.zmaxU) continue;
        data.SP[Nb] = (*r);
        if (++Nb==m_maxsizeSP) goto breakb;
      }
    }
  breakb:
    if (!Nb || Nb==m_maxsizeSP) continue;
    int Nt = Nb;
    
    // Top   links production
    //
    for (int i=0; i<numberTopCells; ++i) {
      
      for (r=rt[i]; r!=rte[i]; ++r) {
  
        float Rt =(*r)->radius();
        float dR = Rt-R;
  
        if (dR<m_drmin) {
          rt[i]=r;
          continue;
        }
        if (dR>m_drmax) break;
        if ((*r)->sur()==sur0) continue;
 
        // Comparison with  bottom and top Z 
        //
        float Tz = ((*r)->z()-Z)/dR;
        float Zo = Z-R*Tz;
        if (Zo < data.zminB || Zo > data.zmaxB) continue;
        float Zu = Z+(550.f-R)*Tz;
        if (Zu < data.zminU || Zu > data.zmaxU) continue;
        data.SP[Nt] = (*r);
        if (++Nt==m_maxsizeSP) goto breakt;
      }
    }
    
  breakt:
    if (!(Nt-Nb)) continue;
    float covr0 = (*r0)->covr ();
    float covz0 = (*r0)->covz ();
 
    float ax   = X/R;
    float ay   = Y/R;
    
    for (int i=0; i<Nt; ++i) {
 
      InDet::SiSpacePointForSeed* sp = data.SP[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.f/(x*x+y*y);
      float dr  = std::sqrt(r2);
      float tz  = dz*dr;
      if (i < Nb) tz = -tz;
 
      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;
    }
    covr0      *= .5f;
    covz0      *= 2.f;
   
    // Three space points comparison
    //
    for (int b=0; 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.f+Tzb*Tzb);
      float  CSA  = Tzb2*COFK;
      float ICSA  = Tzb2*ipt2C;
      float d0max  = maxd0cut;
      if (data.SP[b]->spacepoint->clusterList().second) d0max = maxd0cutstrips;
      
      for (int t=Nb;  t<Nt; ++t) {
  
        float dT  = ((Tzb-data.Tz[t])*(Tzb-data.Tz[t])-data.R[t]*Rb2z-(Erb+data.Er[t]))-(data.R[t]*Rb2r)*((Tzb+data.Tz[t])*(Tzb+data.Tz[t]));
        if ( dT > ICSA) continue;
 
        float deltaU  = data.U[t]-Ub;
        if (deltaU == 0.) continue;
        float A   = (data.V[t]-Vb)/deltaU;
        float onePlusAsquare  = 1.f+A*A;
        float B   = Vb-A*Ub;
        float BSquare  = B*B;
        if (BSquare  > ipt2K*onePlusAsquare || dT*onePlusAsquare > BSquare*CSA) continue;
 
        float Im  = std::abs((A-B*R)*R);
        if (Im > d0max) continue;
 
        // Azimuthal angle test
        //
        float y  = 1.;
        float x  = 2.f*B*R-A;
        float df = std::abs(std::atan2(ay*y-ax*x,ax*y+ay*x)-data.ftrig);
        if (df > M_PI) df = twoPi-df;
        if (df > data.ftrigW) continue;
        data.CmSp.emplace_back(B/std::sqrt(onePlusAsquare), data.SP[t]);
        data.SP[t]->setParam(Im);
      }
      if (!data.CmSp.empty()) {
        newOneSeedWithCurvaturesComparison(data, data.SP[b], (*r0), Zob);
      }
    }
    fillSeeds(data);
    nseed += data.fillOneSeeds;
  }
}

writeNtuple()

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

overridevirtual

This method is called by the SiSPSeededTrackFinder algorithm to fill ntuples for seeds seen by the algorithm.

Method to write ntuple entries for an input seed.

seedType represents Pixel/SCT type seeds, where 0->SCT and 1->Pixel. givesTrack is determined by whether or not the given seed forms atleast one track candidate. 0->No track candidate 1->At least one track Candidate

Definition at line 2482 of file SiSpacePointsSeedMaker_ATLxk.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 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 514 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [2/24]

float m_trackEta InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 513 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [3/24]

float m_trackPt InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 512 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [4/24]

bool m_givesTrack InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 511 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [5/24]

double m_dzdr_b InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 510 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [6/24]

double m_dzdr_t InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 509 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [7/24]

int m_type InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 508 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [8/24]

float m_quality InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 507 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [9/24]

double m_r3 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 506 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [10/24]

double m_r2 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 505 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [11/24]

double m_r1 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 504 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [12/24]

double m_z3 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 503 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [13/24]

double m_z2 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 502 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [14/24]

double m_z1 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 501 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [15/24]

double m_y3 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 500 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [16/24]

double m_y2 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 499 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [17/24]

double m_y1 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 498 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [18/24]

double m_x3 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 497 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [19/24]

double m_x2 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 496 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [20/24]

double m_x1 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 495 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [21/24]

float m_eta InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 494 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [22/24]

float m_pt InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 493 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [23/24]

float m_z0 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 492 of file SiSpacePointsSeedMaker_ATLxk.h.

ATLAS_THREAD_SAFE [24/24]

float m_d0 InDet::SiSpacePointsSeedMaker_ATLxk::ATLAS_THREAD_SAFE = 0

mutableprivate

Definition at line 491 of file SiSpacePointsSeedMaker_ATLxk.h.

m_alwaysKeepConfirmedPixelSeeds

BooleanProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_alwaysKeepConfirmedPixelSeeds {this, "alwaysKeepConfirmedPixelSeeds", false}

private

This flag will lead to all confirmed seeds (seeds where a second compatible seed with a different top spacepoint is found) being kept, even in excess of maxSeedsForSpacePoint above.

Definition at line 188 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "alwaysKeepConfirmedPixelSeeds", false};

m_alwaysKeepConfirmedStripSeeds

BooleanProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_alwaysKeepConfirmedStripSeeds {this, "alwaysKeepConfirmedStripSeeds", false}

private

Definition at line 189 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "alwaysKeepConfirmedStripSeeds", false};

m_beamSpotKey

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

private

Definition at line 167 of file SiSpacePointsSeedMaker_ATLxk.h.

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

m_binSizeR

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_binSizeR {this, "radStep", 2.}

private

Definition at line 210 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "radStep", 2.};

m_checketa

BooleanProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_checketa {this, "checkEta", false}

private

Definition at line 226 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "checkEta", false};

m_COF

float InDet::SiSpacePointsSeedMaker_ATLxk::m_COF {134*.05f*9}

staticconstexprprivate

appears to be an approximated term related to multiple-scattering of particles traversing the ID during the seed formation

Definition at line 255 of file SiSpacePointsSeedMaker_ATLxk.h.

{134*.05f*9};    

m_dImpactCutSlopeUnconfirmedPPP

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_dImpactCutSlopeUnconfirmedPPP {this, "dImpactCutSlopeUnconfirmedPPP", 0.}

private

Definition at line 218 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "dImpactCutSlopeUnconfirmedPPP", 0.};

m_dImpactCutSlopeUnconfirmedSSS

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_dImpactCutSlopeUnconfirmedSSS {this, "dImpactCutSlopeUnconfirmedSSS", 1.0}

private

these flags allow to dynamically tighten the d0 cut on non-confirmed seeds based on the penalty score they receive for kinking in the r-z plane.

The cut is adapted as cut_value = original - slope x penalty

Definition at line 217 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "dImpactCutSlopeUnconfirmedSSS", 1.0};

m_drmax

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_drmax {this, "maxdRadius", 270.}

private

Definition at line 199 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxdRadius", 270.};

m_drmin

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_drmin {this, "mindRadius", 5.}

private

Definition at line 211 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "mindRadius", 5.};

m_drminv

float InDet::SiSpacePointsSeedMaker_ATLxk::m_drminv {20.}

private

Definition at line 244 of file SiSpacePointsSeedMaker_ATLxk.h.

{20.};

m_dzdrmax0

float InDet::SiSpacePointsSeedMaker_ATLxk::m_dzdrmax0 {0.}

private

implicitly store eta cut

Definition at line 251 of file SiSpacePointsSeedMaker_ATLxk.h.

{0.};   

m_dzdrmin0

float InDet::SiSpacePointsSeedMaker_ATLxk::m_dzdrmin0 {0.}

private

conversion factors and cached cut values

implicitly store eta cut

Definition at line 250 of file SiSpacePointsSeedMaker_ATLxk.h.

{0.};   

m_dzdrver

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_dzdrver {this, "maxdZdRver", .02}

private

Definition at line 203 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxdZdRver", .02};

m_dzver

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_dzver {this, "maxdZver", 5.}

private

Definition at line 202 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxdZver", 5.};

m_etamax

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_etamax {this, "etaMax", 2.7}

private

Definition at line 194 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "etaMax", 2.7};

m_etamin

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_etamin {this, "etaMin", 0.}

private

Definition at line 208 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "etaMin", 0.};

m_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> InDet::SiSpacePointsSeedMaker_ATLxk::m_fieldCondObjInputKey

private

Initial value:

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

Read handle for conditions object to get the field cache.

Definition at line 169 of file SiSpacePointsSeedMaker_ATLxk.h.

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

m_fieldScale

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_fieldScale {this, "fieldScale", 1.}

private

Definition at line 221 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "fieldScale", 1.};

m_inverseBinSizePhi

float InDet::SiSpacePointsSeedMaker_ATLxk::m_inverseBinSizePhi {0}

private

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

Definition at line 262 of file SiSpacePointsSeedMaker_ATLxk.h.

{0};   

m_inverseBinSizePhiVertex

float InDet::SiSpacePointsSeedMaker_ATLxk::m_inverseBinSizePhiVertex {0}

private

as above but for vertex

Definition at line 263 of file SiSpacePointsSeedMaker_ATLxk.h.

{0};

m_ipt

float InDet::SiSpacePointsSeedMaker_ATLxk::m_ipt {0.}

private

inverse of 90% of the ptmin cut

Definition at line 252 of file SiSpacePointsSeedMaker_ATLxk.h.

{0.};    

m_ipt2

float InDet::SiSpacePointsSeedMaker_ATLxk::m_ipt2 {0.}

private

inverse square of 90% of the pt min cut

Definition at line 253 of file SiSpacePointsSeedMaker_ATLxk.h.

{0.};   

m_maxBinPhiVertex

int InDet::SiSpacePointsSeedMaker_ATLxk::m_maxBinPhiVertex {0}

private

number of bins in phi for vertices

Definition at line 261 of file SiSpacePointsSeedMaker_ATLxk.h.

{0};     

m_maxdImpact

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_maxdImpact {this, "maxdImpact", 10.}

private

Definition at line 212 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxdImpact", 10.};

m_maxdImpactDecays

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_maxdImpactDecays {this, "maxdImpactForDecays", 20.}

private

Definition at line 219 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxdImpactForDecays", 20.};

m_maxdImpactSSS

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_maxdImpactSSS {this, "maxdImpactSSS", 50.}

private

Definition at line 213 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxdImpactSSS", 50.};

m_maxOneSizePPP

IntegerProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_maxOneSizePPP {this, "maxSeedsForSpacePointPixels", 5}

private

Definition at line 184 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxSeedsForSpacePointPixels", 5};

m_maxOneSizeSSS

IntegerProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_maxOneSizeSSS {this, "maxSeedsForSpacePointStrips", 5}

private

maximum number of seeds to keep per central space point.

the top N seeds sorted by quality are preserved if more candidates than the limit exist

Definition at line 183 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxSeedsForSpacePointStrips", 5};

m_maxPhiBin

int InDet::SiSpacePointsSeedMaker_ATLxk::m_maxPhiBin {0}

private

number of bins in phi

Definition at line 260 of file SiSpacePointsSeedMaker_ATLxk.h.

{0};           

m_maxScore

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_maxScore {this, "maximumAcceptedSeedScore", 100.}

private

Maximum score to accept.

Definition at line 240 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maximumAcceptedSeedScore", 100.}; 

m_maxsize

IntegerProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_maxsize {this, "maxSize", 50000}

private

Definition at line 178 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxSize", 50000};

m_maxsizeSP

IntegerProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_maxsizeSP {this, "maxSizeSP", 5000}

private

Definition at line 179 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxSizeSP", 5000};

m_mutex

std::mutex InDet::SiSpacePointsSeedMaker_ATLxk::m_mutex

mutableprivate

Definition at line 486 of file SiSpacePointsSeedMaker_ATLxk.h.

m_nBinsR

int InDet::SiSpacePointsSeedMaker_ATLxk::m_nBinsR {0}

private

number of bins in the radial coordinate

Definition at line 259 of file SiSpacePointsSeedMaker_ATLxk.h.

{0};              

m_neighbourCellsBottom

std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> InDet::SiSpacePointsSeedMaker_ATLxk::m_neighbourCellsBottom {}

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 287 of file SiSpacePointsSeedMaker_ATLxk.h.

{}; 

m_neighbourCellsTop

std::array<std::array<int, arraySizeNeighbourBins>, arraySizePhiZ> InDet::SiSpacePointsSeedMaker_ATLxk::m_neighbourCellsTop {}

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 288 of file SiSpacePointsSeedMaker_ATLxk.h.

{}; 

m_neighboursVertexPhiZ

std::array<std::array<int, arraySizeNeighbourBinsVertex>, arraySizePhiZV> InDet::SiSpacePointsSeedMaker_ATLxk::m_neighboursVertexPhiZ {}

private

Definition at line 291 of file SiSpacePointsSeedMaker_ATLxk.h.

{};

m_nNeighbourCellsBottom

std::array<int,arraySizePhiZ> InDet::SiSpacePointsSeedMaker_ATLxk::m_nNeighbourCellsBottom {}

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 285 of file SiSpacePointsSeedMaker_ATLxk.h.

{};  

m_nNeighbourCellsTop

std::array<int,arraySizePhiZ> InDet::SiSpacePointsSeedMaker_ATLxk::m_nNeighbourCellsTop {}

private

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

Definition at line 286 of file SiSpacePointsSeedMaker_ATLxk.h.

{};  

m_nNeighboursVertexPhiZ

std::array<int,arraySizePhiZV> InDet::SiSpacePointsSeedMaker_ATLxk::m_nNeighboursVertexPhiZ {}

private

Definition at line 290 of file SiSpacePointsSeedMaker_ATLxk.h.

{};

m_optimisePhiBinning

BooleanProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_optimisePhiBinning {this, "optimisePhiBinning", true}

private

This flag will make the buildFrameWork method determine an optimal phi binning of the search regions based on the pt and IP cuts, assuming PPP and/or SSS passes are being run.

Not recommended for use with Large-R Tracking, where unnecessarily large regions may result.

Definition at line 193 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "optimisePhiBinning", true};

m_outputTree

TTree* InDet::SiSpacePointsSeedMaker_ATLxk::m_outputTree

private

Definition at line 484 of file SiSpacePointsSeedMaker_ATLxk.h.

m_pixel

BooleanProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_pixel {this, "usePixel", true}

private

Definition at line 175 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "usePixel", true};

m_prdToTrackMap

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

private

Definition at line 166 of file SiSpacePointsSeedMaker_ATLxk.h.

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

m_ptmin

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_ptmin {this, "pTmin", 500.}

private

Definition at line 220 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "pTmin", 500.};

m_r1maxv

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_r1maxv {this, "maxVRadius1", 60.}

private

Definition at line 196 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxVRadius1", 60.};

m_r1minv

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_r1minv {this, "minVRadius1", 0.}

private

Definition at line 195 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "minVRadius1", 0.};

m_r2maxv

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_r2maxv {this, "maxVRadius2", 200.}

private

Definition at line 198 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "maxVRadius2", 200.};

m_r2minv

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_r2minv {this, "minVRadius2", 70.}

private

Definition at line 197 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "minVRadius2", 70.};

m_r_rmax

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_r_rmax {this, "radMax", 600.}

private

Definition at line 209 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "radMax", 600.};

m_radiusCutIBL

float InDet::SiSpacePointsSeedMaker_ATLxk::m_radiusCutIBL {43.}

staticconstexprprivate

We detect IBL hits via the seed radial location.

Place the cut value roughly between IBL and L0

Definition at line 282 of file SiSpacePointsSeedMaker_ATLxk.h.

{43.}; 

m_sct

BooleanProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_sct {this, "useSCT", true}

private

Definition at line 176 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "useSCT", true};

m_seedScoreBonusConfirmationSeed

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_seedScoreBonusConfirmationSeed {this, "seedScoreBonusConfirmationSeed", -200.}

private

Definition at line 236 of file SiSpacePointsSeedMaker_ATLxk.h.

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

m_seedScoreBonusPPP

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_seedScoreBonusPPP {this, "seedScoreBonusPPP", -200.}

private

Scoring modifiers applied when ranking seeds.

These are used within the newOneSeedWithCurvaturesComparison method. Be aware that a negative score is considered "better", so these should be set to negative numbers.

Definition at line 234 of file SiSpacePointsSeedMaker_ATLxk.h.

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

m_seedScoreBonusSSS

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_seedScoreBonusSSS {this, "seedScoreBonusSSS", -400.}

private

Definition at line 235 of file SiSpacePointsSeedMaker_ATLxk.h.

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

m_seedScoreThresholdPPPConfirmationSeed

float InDet::SiSpacePointsSeedMaker_ATLxk::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 276 of file SiSpacePointsSeedMaker_ATLxk.h.

{0.};    

m_seedScoreThresholdSSSConfirmationSeed

float InDet::SiSpacePointsSeedMaker_ATLxk::m_seedScoreThresholdSSSConfirmationSeed {0.}

private

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

Definition at line 277 of file SiSpacePointsSeedMaker_ATLxk.h.

{0.};    

m_spacepointsOverlap

SG::ReadHandleKey<SpacePointOverlapCollection> InDet::SiSpacePointsSeedMaker_ATLxk::m_spacepointsOverlap {this, "SpacePointsOverlapName", "OverlapSpacePoints"}

private

Definition at line 165 of file SiSpacePointsSeedMaker_ATLxk.h.

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

m_spacepointsPixel

SG::ReadHandleKey<SpacePointContainer> InDet::SiSpacePointsSeedMaker_ATLxk::m_spacepointsPixel {this, "SpacePointsPixelName", "PixelSpacePoints", "Pixel space points container"}

private

Definition at line 163 of file SiSpacePointsSeedMaker_ATLxk.h.

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

m_spacepointsSCT

SG::ReadHandleKey<SpacePointContainer> InDet::SiSpacePointsSeedMaker_ATLxk::m_spacepointsSCT {this, "SpacePointsSCTName", "SCT_SpacePoints", "SCT space points container"}

private

Definition at line 164 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "SpacePointsSCTName", "SCT_SpacePoints", "SCT space points container"};

m_thistSvc

ServiceHandle<ITHistSvc> InDet::SiSpacePointsSeedMaker_ATLxk::m_thistSvc

private

Definition at line 482 of file SiSpacePointsSeedMaker_ATLxk.h.

m_treeFolder

std::string InDet::SiSpacePointsSeedMaker_ATLxk::m_treeFolder

private

Definition at line 489 of file SiSpacePointsSeedMaker_ATLxk.h.

m_treeName

std::string InDet::SiSpacePointsSeedMaker_ATLxk::m_treeName

private

Definition at line 488 of file SiSpacePointsSeedMaker_ATLxk.h.

m_useOverlap

BooleanProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_useOverlap {this, "useOverlapSpCollection", true}

private

Definition at line 177 of file SiSpacePointsSeedMaker_ATLxk.h.

{this, "useOverlapSpCollection", true};

m_writeNtuple

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

private

Flag to write validation ntuples. Turned off by default.

Definition at line 480 of file SiSpacePointsSeedMaker_ATLxk.h.

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

m_zmax

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_zmax {this, "maxZ", +250.}

private

Definition at line 201 of file SiSpacePointsSeedMaker_ATLxk.h.

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

m_zmin

FloatProperty InDet::SiSpacePointsSeedMaker_ATLxk::m_zmin {this, "minZ", -250.}

private

Definition at line 200 of file SiSpacePointsSeedMaker_ATLxk.h.

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

---

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

• SiSpacePointsSeedMaker_ATLxk.h
• SiSpacePointsSeedMaker_ATLxk.cxx