#include <StripSpacePointFormationTool.h>

Inheritance diagram for ActsTrk::StripSpacePointFormationTool:

Collaboration diagram for ActsTrk::StripSpacePointFormationTool:

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

virtual	~StripSpacePointFormationTool ()=default

virtual StatusCode	initialize () override

Private Attributes
Id helpers
const SCT_ID *	m_stripId {}

tool handles
ToolHandle< ISiLorentzAngleTool >	m_lorentzAngleTool
	Using Lorentz angle tool. More...

Configuration flags
Gaudi::Property< bool >	m_allClusters {this, "AllClusters", false, "Process all clusters without limits."}

Cut parameters
The following are ranges within which clusters must lie to make a spacepoint. Opposite and eta neighbours clusters must lie within range of each other. Phi clusters must lie in region of each wafer separately.
Gaudi::Property< float >	m_overlapLimitOpposite {this, "OverlapLimitOpposite", 2.8, "Overlap limit for opposite-neighbour."}

Gaudi::Property< float >	m_overlapLimitPhi {this, "OverlapLimitPhi", 5.64, "Overlap limit for phi-neighbours."}

Gaudi::Property< float >	m_overlapLimitEtaMin {this, "OverlapLimitEtaMin", 1.68, "Low overlap limit for eta-neighbours."}

Gaudi::Property< float >	m_overlapLimitEtaMax {this, "OverlapLimitEtaMax", 3.0, "High overlap limit for eta-neighbours."}

Gaudi::Property< float >	m_stripLengthTolerance {this, "StripLengthTolerance", 0.01}
	The following are parameters to build the space points. More...

Gaudi::Property< float >	m_stripGapParameter {this, "StripGapParameter", 0.0015, "Recommend 0.001 - 0.0015 for ITK geometry"}

Production of space points
virtual StatusCode	produceSpacePoints (const EventContext &ctx, const xAOD::StripClusterContainer &clusterContainer, const InDet::SiElementPropertiesTable &properties, const InDetDD::SiDetectorElementCollection &elements, const Amg::Vector3D &beamSpotVertex, std::vector< StripSP > &spacePoints, std::vector< StripSP > &overlapSpacePoints, bool processOverlaps, const std::vector< IdentifierHash > &hashesToProcess, const ContainerAccessor< xAOD::StripCluster, IdentifierHash, 1 > &stripAccessor) const override

StatusCode	fillStripSpacePoints (const std::array< const InDetDD::SiDetectorElement , nNeighbours > &neighbourElements, const std::array< std::vector< std::pair< const xAOD::StripCluster , size_t >>, nNeighbours > &neighbourClusters, const std::array< double, 14 > &overlapExtents, const Amg::Vector3D &beamSpotVertex, std::vector< StripSP > &spacePoints, std::vector< StripSP > &overlapSpacePoints) const

StatusCode	makeStripSpacePoint (std::vector< StripSP > &, const StripInformationHelper &firstInfo, const StripInformationHelper &secondInfo, bool isEndcap, double limit, double slimit) const

void	updateRange (const InDetDD::SiDetectorElement element1, const InDetDD::SiDetectorElement element2, double &stripLengthGapTolerance, double &min, double &max) const

double	offset (const InDetDD::SiDetectorElement element1, const InDetDD::SiDetectorElement element2, double &stripLengthGapTolerance) const

void	correctPolarRange (const InDetDD::SiDetectorElement *element, double &min, double &max, size_t &minStrip, size_t &maxStrip) const

std::pair< Amg::Vector3D, Amg::Vector3D >	getStripEnds (const xAOD::StripCluster cluster, const InDetDD::SiDetectorElement element, size_t &stripIndex) const

Detailed Description

Definition at line 34 of file StripSpacePointFormationTool.h.

Constructor & Destructor Documentation

◆ StripSpacePointFormationTool()

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

Definition at line 16 of file StripSpacePointFormationTool.cxx.

19 : base_class(type, name, parent)

20 {}

◆ ~StripSpacePointFormationTool()

virtual ActsTrk::StripSpacePointFormationTool::~StripSpacePointFormationTool ( )

virtualdefault

Member Function Documentation

◆ correctPolarRange()

void ActsTrk::StripSpacePointFormationTool::correctPolarRange	(	const InDetDD::SiDetectorElement *	element,
		double &	min,
		double &	max,
		size_t &	minStrip,
		size_t &	maxStrip
	)		const

private

Definition at line 550 of file StripSpacePointFormationTool.cxx.

     {
         if (element->isBarrel())
             return;
  
         // design for endcap modules
         const InDetDD::StripStereoAnnulusDesign *design
             = dynamic_cast<const InDetDD::StripStereoAnnulusDesign *> (&element->design());
         if ( design==nullptr ) {
             ATH_MSG_FATAL( "Invalid strip annulus design for module with identifier/identifierHash " << element->identify() << "/" << element->identifyHash());
             return;
         }
  
         // converting min and max from cartesian reference frame to polar frame
         auto firstPosition = (design->localPositionOfCell(design->strip1Dim(0, 0))+
             design->localPositionOfCell(design->strip1Dim(design->diodesInRow(0)-1, 0)))*0.5;
  
         double radius = firstPosition.xEta();
  
         InDetDD::SiCellId minCellId = element->cellIdOfPosition(InDetDD::SiLocalPosition(radius, min, 0.));
         InDetDD::SiCellId maxCellId = element->cellIdOfPosition(InDetDD::SiLocalPosition(radius, max, 0.));
  
         if (not minCellId.isValid()) {
             minCellId = InDetDD::SiCellId(0);
         }
  
         if (not maxCellId.isValid()) {
             maxCellId = InDetDD::SiCellId(design->diodesInRow(0)-1);
         }
  
         minStrip = minCellId.strip();
         maxStrip = maxCellId.strip();
  
         // re-evaluate min and max in polar coordinate
     min = std::atan2(min, radius);
     max = std::atan2(max, radius);
     }

◆ fillStripSpacePoints()

StatusCode ActsTrk::StripSpacePointFormationTool::fillStripSpacePoints	(	const std::array< const InDetDD::SiDetectorElement *, nNeighbours > &	neighbourElements,
		const std::array< std::vector< std::pair< const xAOD::StripCluster *, size_t >>, nNeighbours > &	neighbourClusters,
		const std::array< double, 14 > &	overlapExtents,
		const Amg::Vector3D &	beamSpotVertex,
		std::vector< StripSP > &	spacePoints,
		std::vector< StripSP > &	overlapSpacePoints
	)		const

private

Definition at line 213 of file StripSpacePointFormationTool.cxx.

     {
  
         // This function is called once all the needed quantities are collected.
         // It is used to build space points checking the compatibility of clusters on pairs of detector elements.
         // Detector elements and cluster collections are elements and clusters, respectively.
         // [0] is the trigger element
         // [1] is the opposite element
         // [2]-[3] are the elements tested for eta overlaps
         // [4]-[5] are the elements tested for phi overlaps
         //
         // To build space points:
         // - For the opposite element and the ones tested for eta overlaps, you have to check
         //   if clusters are compatible with the local position of the trigger cluster
         //   requiring that the distance between the two clusters in phi is withing a specified range.
         //   - overlapExtents[0], overlapExtents[1] are filled for the opposite element
         //   - overlapExtents[2], overlapExtents[3], overlapExtents[4], overlapExtents[5] are filled for the eta overlapping elements
         // - For the elements tested for phi overlaps, you have to check
         //   if clusters are compatible with the local position of the trigger cluster.
         //   This needs that the trigger cluster is at the edge of the trigger module
         //   and that the other cluster is on the compatible edge of its module
         //   - overlapExtents[6], overlapExtents[7], overlapExtents[10], overlapExtents[11]
         //     overlapExtents[8], overlapExtents[9], overlapExtents[12], overlapExtents[13] are filled for the phi overlapping elements
  
         constexpr int otherSideIndex{1};
         constexpr int maxEtaIndex{3};
         std::array<int, nNeighbours-1> elementIndex{};
         int nElements = 0;
  
         // For the nNeighbours sides, fill elementIndex with the indices of the existing elements.
         // Same the number of elements in nElements to loop on the later on
         for(int n=1; n!=nNeighbours; ++n) {
             if(elements[n]) {
                 elementIndex[nElements++] = n;
             }
         }
         // return if all detector elements are nullptr
         if(!nElements) return StatusCode::SUCCESS;
  
         // trigger element and clusters
         const InDetDD::SiDetectorElement* element = elements[0];
         bool isEndcap = element->isEndcap();
  
         std::vector<StripInformationHelper> stripInfos;
         stripInfos.reserve(clusters[0].size());
  
         // loop on all clusters on the trigger detector element and save the related information
         for (auto& cluster_index : clusters[0]) {
             size_t stripIndex = -1;
             auto ends = getStripEnds(cluster_index.first, element, stripIndex);
             const auto& localPos = cluster_index.first->localPosition<1>();
             StripInformationHelper stripInfo(cluster_index.first->identifierHash(), ends.first, ends.second, beamSpotVertex, localPos(0, 0), cluster_index.second, stripIndex);
             stripInfos.push_back( std::move(stripInfo) );
         }
  
         double  limit  = 1. + m_stripLengthTolerance;
         double slimit  = 0.;
  
         if(not m_allClusters) {
             // Start processing the opposite side and the eta overlapping elements
             int n = 0;
             for(; n < nElements; ++n) {
                 int currentIndex = elementIndex[n];
                 if(currentIndex > maxEtaIndex) break;
  
                 // get the detector element and the IdentifierHash
                 const InDetDD::SiDetectorElement* currentElement  = elements[currentIndex];
  
                 // retrieve the range
                 double min = overlapExtents[currentIndex*2-2];
                 double max = overlapExtents[currentIndex*2-1];
  
                 size_t minStrip, maxStrip = 0;
  
                 if (m_stripGapParameter != 0.) {
                     updateRange(element, currentElement, slimit, min, max);
                     correctPolarRange(element, min, max, minStrip, maxStrip);
                 }
  
                 StripInformationHelper currentStripInfo;
                 for (auto& cluster_index : clusters[currentIndex]) {
                     bool processed = false;
                     const auto& currentLocalPos = cluster_index.first->localPosition<1>();
  
                     for(auto& stripInfo : stripInfos) {
                         double diff = currentLocalPos(0, 0)-stripInfo.locX();
  
                         if(diff < min || diff > max) continue;
  
                         if (not processed) {
                             processed = true;
                             size_t currentStripIndex = 0;
                             auto ends = getStripEnds(cluster_index.first, currentElement, currentStripIndex);
                             currentStripInfo.set(cluster_index.first->identifierHash(), ends.first, ends.second, beamSpotVertex, currentLocalPos(0, 0), cluster_index.second, currentStripIndex);
                         }
  
                         // depending on the index you are processing, you save the space point in the correct container
                         if (currentIndex==otherSideIndex) {
               ATH_CHECK( makeStripSpacePoint(spacePoints, stripInfo, currentStripInfo, isEndcap, limit, slimit) );
                         } else {
               ATH_CHECK( makeStripSpacePoint(overlapSpacePoints, stripInfo, currentStripInfo, isEndcap, limit, slimit) );
                         }
                     }
                 }
             }
             // process the phi overlapping elements
             // if possible n starts from 4
             for(; n < nElements; ++n) {
                 int currentIndex = elementIndex[n];
                 const InDetDD::SiDetectorElement* currentElement = elements[currentIndex];
  
                 double min = overlapExtents[4*currentIndex-10];
                 double max = overlapExtents[4*currentIndex- 9];
  
                 std::size_t minStrip = 0;
                 std::size_t maxStrip = 0;
  
                 if (m_stripGapParameter != 0.) {
                     updateRange(element, currentElement, slimit, min, max);
                     correctPolarRange(element, min, max, minStrip, maxStrip);
                 }
  
                 std::vector<StripInformationHelper*> stripPhiInfos;
                 stripPhiInfos.reserve(stripInfos.size());
  
                 for(auto& stripInfo : stripInfos) {
                     auto stripIndex = stripInfo.stripIndex();
                     auto localPosition = stripInfo.locX();
                     auto centralValue = localPosition;
                     auto minValue = min;
                     auto maxValue = max;
                     if (isEndcap) {
                         centralValue = stripIndex;
                         minValue = minStrip;
                         maxValue = maxStrip;
                     }
  
                     if (minValue <= centralValue and centralValue <= maxValue) {
                         stripPhiInfos.push_back(&stripInfo);
                     }
                 }
                 // continue if you have no cluster from the phi overlapping region of the trigger element
                 if(stripPhiInfos.empty()) continue;
  
                 min = overlapExtents[4*currentIndex-8];
                 max = overlapExtents[4*currentIndex-7];
  
                 if (m_stripGapParameter != 0.) {
                     updateRange(element, currentElement, slimit, min, max);
                     correctPolarRange(currentElement, min, max, minStrip, maxStrip);
                 }
  
                 for (auto& cluster_index : clusters[currentIndex]) {
                     const auto& currentLocalPos = cluster_index.first->localPosition<1>();
  
                     size_t currentStripIndex = 0;
                     auto ends = getStripEnds(cluster_index.first, currentElement, currentStripIndex);
                     StripInformationHelper currentStripInfo(cluster_index.first->identifierHash(), ends.first, ends.second, beamSpotVertex, currentLocalPos(0, 0), cluster_index.second, currentStripIndex);
                     auto centralValue = currentLocalPos(0, 0);
                     auto minValue = min;
                     auto maxValue = max;
                     if (isEndcap) {
                         centralValue = currentStripIndex;
                         minValue = minStrip;
                         maxValue = maxStrip;
                     }
  
                     if (centralValue < minValue or centralValue > maxValue)
                         continue;
  
                     for(auto& stripInfo : stripPhiInfos) {
               ATH_CHECK( makeStripSpacePoint(overlapSpacePoints, *stripInfo, currentStripInfo, isEndcap, limit, slimit) );
                     }
                 }
             }
             return StatusCode::SUCCESS;
         }
  
         for(int n=0; n!=nElements; ++n) {
       
             int currentIndex = elementIndex[n];
             const InDetDD::SiDetectorElement* currentElement = elements[currentIndex];
  
             if (m_stripGapParameter != 0.) {
                 offset(element, currentElement, slimit);
             }
  
             for (auto& cluster_index : clusters[currentIndex]) {
                 size_t currentStripIndex = 0;
                 auto ends = getStripEnds(cluster_index.first, element, currentStripIndex);
                 const auto& currentLocalPos = cluster_index.first->localPosition<1>();
                 StripInformationHelper currentStripInfo(cluster_index.first->identifierHash(), ends.first, ends.second, beamSpotVertex, currentLocalPos(0, 0), cluster_index.second, currentStripIndex);
  
                 for(auto& stripInfo : stripInfos) {
                     // depending on the index you are processing, you save the space point in the correct container
                     if (currentIndex==otherSideIndex) {
               ATH_CHECK( makeStripSpacePoint(spacePoints, stripInfo, currentStripInfo, isEndcap, limit, slimit) );
                     } else {
               ATH_CHECK( makeStripSpacePoint(overlapSpacePoints, stripInfo, currentStripInfo, isEndcap, limit, slimit) );
                     }
                 }
             }
         }
     return StatusCode::SUCCESS;
     }

◆ getStripEnds()

std::pair< Amg::Vector3D, Amg::Vector3D > ActsTrk::StripSpacePointFormationTool::getStripEnds	(	const xAOD::StripCluster *	cluster,
		const InDetDD::SiDetectorElement *	element,
		size_t &	stripIndex
	)		const

private

Definition at line 593 of file StripSpacePointFormationTool.cxx.

     {
         const Eigen::Matrix<float,1,1>& localPos = cluster->localPosition<1>();
  
         if (element->isEndcap()) {
             // design for endcap modules
             const InDetDD::StripStereoAnnulusDesign *design
                 = dynamic_cast<const InDetDD::StripStereoAnnulusDesign *> (&element->design());
             if ( design==nullptr ) {
                 ATH_MSG_FATAL( "Invalid strip annulus design for module with identifier/identifierHash " << element->identify() << "/" << element->identifyHash());
                 return std::pair<Amg::Vector3D, Amg::Vector3D >();
             }
  
             // calculate phi pitch for evaluating the strip index
             double phiPitchPhi = design->phiWidth()/design->diodesInRow(0);
             stripIndex = -std::floor(localPos(0, 0) / phiPitchPhi) + design->diodesInRow(0) *0.5 - 0.5;
  
             std::pair<Amg::Vector3D, Amg::Vector3D > ends = {
                 element->globalPosition(design->stripPosAtR(stripIndex, 0, design->minR())),
                 element->globalPosition(design->stripPosAtR(stripIndex, 0, design->maxR()))
             };
             return ends;
  
         }
  
         InDetDD::SiLocalPosition localPosition(0., localPos(0, 0), 0.);
         std::pair<Amg::Vector3D, Amg::Vector3D > ends(element->endsOfStrip(localPosition));
  
         return ends;
     }

◆ initialize()

StatusCode ActsTrk::StripSpacePointFormationTool::initialize ( )

overridevirtual

Definition at line 22 of file StripSpacePointFormationTool.cxx.

                                                         {
  
         ATH_CHECK(detStore()->retrieve(m_stripId,"SCT_ID"));
  
         ATH_CHECK(m_lorentzAngleTool.retrieve());
  
         return StatusCode::SUCCESS;
     }

◆ makeStripSpacePoint()

StatusCode ActsTrk::StripSpacePointFormationTool::makeStripSpacePoint	(	std::vector< StripSP > &	collection,
		const StripInformationHelper &	firstInfo,
		const StripInformationHelper &	secondInfo,
		bool	isEndcap,
		double	limit,
		double	slimit
	)		const

private

Definition at line 425 of file StripSpacePointFormationTool.cxx.

     {
         double a  =-firstInfo.trajDirection().dot(secondInfo.normal());
         double b  = firstInfo.stripDirection().dot(secondInfo.normal());
         double l0 = firstInfo.oneOverStrip()*slimit+limit ;
  
         if(std::abs(a) > (std::abs(b)*l0)) {
       return StatusCode::SUCCESS;
         }
  
         double c  =-secondInfo.trajDirection().dot(firstInfo.normal());
         double d  = secondInfo.stripDirection().dot(firstInfo.normal());
         double l1 = secondInfo.oneOverStrip()*slimit+limit ;
  
         if(std::abs(c) > (std::abs(d)*l1)) {
       return StatusCode::SUCCESS;
         }
  
         double m = a/b;
  
         if(slimit!=0.) {
             double n = c/d;
             if (m >  limit || n >  limit) {
                 double cs  = firstInfo.stripDirection().dot(secondInfo.stripDirection())*(firstInfo.oneOverStrip()*firstInfo.oneOverStrip());
                 double dm  = (m-1);
                 double dmn = (n-1.)*cs;
                 if(dmn > dm) dm = dmn;
                 m-=dm; n-=(dm/cs);
                 if(std::abs(m) > limit || std::abs(n) > limit) {
           return StatusCode::SUCCESS;
                 }
             } else if (m < -limit || n < -limit) {
                 double cs  = firstInfo.stripDirection().dot(secondInfo.stripDirection())*(firstInfo.oneOverStrip()*firstInfo.oneOverStrip());
                 double dm  = -(1.+m);
                 double dmn = -(1.+n)*cs;
                 if(dmn > dm) dm = dmn;
                 m+=dm; n+=(dm/cs);
                 if(std::abs(m) > limit || std::abs(n) > limit) {
           return StatusCode::SUCCESS;
                 }
             }
         }
  
     Eigen::Matrix<double, 3, 1> globalPosition(firstInfo.position(m));
  
         // evaluation of the local covariance
         // Lines taken from SCT_SpacePoint::setupLocalCovarianceSCT()
         float deltaY = 0.0004; // roughly pitch of SCT (80 mu) / sqrt(12)
         float covTerm = 1600.*deltaY;
  
         Eigen::Matrix<float, 2, 1> variance(0.1, 8.*covTerm);
         // Swap r/z covariance terms for endcap clusters
         if ( isEndcap )
             std::swap( variance(0, 0), variance(1, 0) );
  
         // evaluation of measurement details
         float topHalfStripLength = 0.5*firstInfo.stripDirection().norm();
         Eigen::Matrix<double, 3, 1> topStripDirection = -firstInfo.stripDirection()/(2.*topHalfStripLength);
         Eigen::Matrix<double, 3, 1> topStripCenter = 0.5*firstInfo.trajDirection();
  
         float bottomHalfStripLength = 0.5*secondInfo.stripDirection().norm();
         Eigen::Matrix<double, 3, 1> bottomStripDirection = -secondInfo.stripDirection()/(2.*bottomHalfStripLength);
  
         Eigen::Matrix<double, 3, 1> stripCenterDistance = firstInfo.stripCenter() - secondInfo.stripCenter();
  
     std::vector<std::size_t> measIndexes({firstInfo.clusterIndex(), secondInfo.clusterIndex()});
  
  
     StripSP toAdd;
     toAdd.idHashes = {firstInfo.idHash(), secondInfo.idHash()};
     toAdd.globPos = globalPosition.cast<float>();
     toAdd.cov_r = variance(0,0);
     toAdd.cov_z = variance(1,0);
     toAdd.measurementIndexes = measIndexes;
     toAdd.topHalfStripLength = topHalfStripLength;
     toAdd.bottomHalfStripLength = bottomHalfStripLength;
     toAdd.topStripDirection = topStripDirection.cast<float>();
     toAdd.bottomStripDirection = bottomStripDirection.cast<float>();
     toAdd.stripCenterDistance = stripCenterDistance.cast<float>();
     toAdd.topStripCenter = topStripCenter.cast<float>();
  
     collection.push_back(toAdd);
  
         return StatusCode::SUCCESS;
     }

◆ offset()

double ActsTrk::StripSpacePointFormationTool::offset	(	const InDetDD::SiDetectorElement *	element1,
		const InDetDD::SiDetectorElement *	element2,
		double &	stripLengthGapTolerance
	)		const

private

Definition at line 517 of file StripSpacePointFormationTool.cxx.

     {
         const Amg::Transform3D& T1 = element1->transform();
         const Amg::Transform3D& T2 = element2->transform();
         Amg::Vector3D           C  = element1->center() ;
         bool isAnnulus = (element1->design().shape() == InDetDD::Annulus);
  
         double x12 = T1(0,0)*T2(0,0)+T1(1,0)*T2(1,0)+T1(2,0)*T2(2,0);
         double r   = isAnnulus ? std::sqrt(C[0]*C[0]+C[1]*C[1]) : std::sqrt(T1(0,3)*T1(0,3)+T1(1,3)*T1(1,3));
         double s   = (T1(0,3)-T2(0,3))*T1(0,2)+(T1(1,3)-T2(1,3))*T1(1,2)+(T1(2,3)-T2(2,3))*T1(2,2);
  
         double dm  = (m_stripGapParameter*r)*std::abs(s*x12);
         double d   = isAnnulus ? dm/.04 : dm/std::sqrt((1.-x12)*(1.+x12));
  
         if (std::abs(T1(2,2)) > 0.7) d*=(r/std::abs(T1(2,3)));
  
         stripLengthGapTolerance = d;
  
         return dm;
     }

◆ produceSpacePoints()

StatusCode ActsTrk::StripSpacePointFormationTool::produceSpacePoints	(	const EventContext &	ctx,
		const xAOD::StripClusterContainer &	clusterContainer,
		const InDet::SiElementPropertiesTable &	properties,
		const InDetDD::SiDetectorElementCollection &	elements,
		const Amg::Vector3D &	beamSpotVertex,
		std::vector< StripSP > &	spacePoints,
		std::vector< StripSP > &	overlapSpacePoints,
		bool	processOverlaps,
		const std::vector< IdentifierHash > &	hashesToProcess,
		const ContainerAccessor< xAOD::StripCluster, IdentifierHash, 1 > &	stripAccessor
	)		const

overridevirtual

Production of StripSP from strip clusters Strip space points involves a more complex logic since they are made combining clusters from pairs of overlapping detectors.

For each trigger element, first evaluate and collect the quantities you need to build the space points. The detector element array has capacity 6: [0] is the trigger element [1] is the opposite element [2]-[3] are the elements tested for eta overlaps [4]-[5] are the elements tested for phi overlaps For each element you save the corresponding cluster collections and the space point compatibility range as described below.

For the opposite element and the ones tested for eta overlaps, you have to check if clusters are compatible with the local position of the trigger cluster requiring that the distance between the two clusters in phi is withing a specified range.

For the clusters on the opposite element: [-m_overlapLimitOpposite, m_overlapLimitOpposite]
For the eta overlapping clusters : you use m_overlapLimitEtaMin and m_overlapLimitEtaMax in different combination depending if you are checking a stereo module or not

For each element, the extremes of these ranges are saved in the overlapExtents array which is used later on

overlapExtents[0], overlapExtents[1] are filled for the opposite element
overlapExtents[2], overlapExtents[3], overlapExtents[4], overlapExtents[5] are filled for the eta overlapping elements

For the elements tested for phi overlaps, you have to check if clusters are compatible with the local position of the trigger cluster. This needs that the trigger cluster is at the edge of the trigger module: e.g. -hwidth < locX_trigger < -hwidth+m_overlapLimitPhi (or hwidth-m_overlapLimitPhi < locX_trigger < hwidth) and that the other cluster is on the compatible edge of its module: e.g. hwidth-m_overlapLimitPhi < locX_other < hwidth (or -hwidth < locX_other < -hwidth+m_overlapLimitPhi)

For each element, the extremes of these ranges are saved in the overlapExtents array which is used later on

overlapExtents[6], overlapExtents[7], overlapExtents[10], overlapExtents[11] overlapExtents[8], overlapExtents[9], overlapExtents[12], overlapExtents[13] are filled for the phi overlapping elements

Access to the cluster from a given detector element is possible via the ContainerAccessor.

Definition at line 31 of file StripSpacePointFormationTool.cxx.

     {
  
  
  
         const auto hashesProc = (hashesToProcess.size() > 0 ? hashesToProcess : stripAccessor.allIdentifiers());
         for (auto& idHash : hashesProc) {
             const InDetDD::SiDetectorElement* thisElement = elements.getDetectorElement(idHash);
             if ( not thisElement->isStereo() ) {
                 // Retrieve the neighbours of the detector element
                 const std::vector<IdentifierHash>* others(properties.neighbours(idHash));
                 if (others==nullptr || others->empty() )
                     continue;
  
                 // This flag is use to trigger if the search should be performed.
                 // In case there are no clusters on the neighbours of the selected
                 // detector element, the flag stays false.
                 bool search=false;
                 size_t neighbour = 0;
                 while (not search and neighbour<others->size() ) {
                     search = stripAccessor.isIdentifierPresent(others->at(neighbour));
                     neighbour++;
                 }
                 if (not search)
                     continue;
  
                 // prepare clusters, indices and modules for space point formation
                 std::array<std::vector<std::pair<const xAOD::StripCluster*, size_t>>, nNeighbours> neighbourClusters{};
                 std::array<const InDetDD::SiDetectorElement*, nNeighbours> neighbourElements{};
  
                 auto groupStart = clusterContainer.begin();
                 // Get the detector element and range for the idHash
                 neighbourElements[0] = thisElement;
                 for (auto& this_range : stripAccessor.rangesForIdentifierDirect(idHash)) {
                     for (auto start=this_range.first; start!=this_range.second; start++) {
                         size_t position = std::distance(groupStart, start);
                         neighbourClusters[0].push_back(std::make_pair(*start, position));
                     }
                 }
  
                 Identifier thisId = thisElement->identify();
  
                 // define overlap extends before building space points
                 std::array<double, 14> overlapExtents{};
                 //   Default case: you test the opposite element and the overlapping in phi (total 3 elements)
                 int Nmax = 4;
  
                 // In the barrel, test the eta overlaps as well (total 5 elements)
                 if (m_stripId->is_barrel(thisId))
                     Nmax = 6;
  
                 // You can remove all the overlaps if requested.
                 // Here you test only the opposite element
                 if(not processOverlaps) Nmax = 2;
  
                 float hwidth(properties.halfWidth(idHash));
                 int n = 0;
  
  
                 // The order of the elements in others is such that you first get the opposite element,
                 // the overlapping in phi and then the overlapping in eta
                 // For this reason you need to re-order the indices, since the SiSpacePointMakerTool will process
                 // first the eta overlaps and then the phi ones
                 const std::array<size_t, nNeighbours> neigbourIndices{ThisOne, Opposite, EtaMinus, EtaPlus, PhiMinus, PhiPlus};
  
                 for (const auto& otherHash : *others) {
  
                     if(++n==Nmax) break;
  
                     if(not stripAccessor.isIdentifierPresent(otherHash))
                         continue;
  
                     const InDetDD::SiDetectorElement* otherElement = elements.getDetectorElement(otherHash);
  
                     neighbourElements[neigbourIndices[n]] = otherElement;
                     for (auto& this_range : stripAccessor.rangesForIdentifierDirect(otherHash)) {
                         for (auto start=this_range.first; start!=this_range.second; start++) {
                             size_t position = std::distance(groupStart, start);
                             neighbourClusters[neigbourIndices[n]].push_back(std::make_pair(*start, position));
                         }
                     }
  
                     switch (n) {
                         case Opposite: {
                             overlapExtents[ 0] = -m_overlapLimitOpposite;
                             overlapExtents[ 1] =  m_overlapLimitOpposite;
                             break;
                         }
                         case PhiMinus: {
                             overlapExtents[ 6] =-hwidth;
                             overlapExtents[ 7] =-hwidth+m_overlapLimitPhi;
                             overlapExtents[ 8] = hwidth-m_overlapLimitPhi;
                             overlapExtents[ 9] = hwidth;
                             break;
                         }
                         case PhiPlus: {
                             overlapExtents[10] = hwidth-m_overlapLimitPhi;
                             overlapExtents[11] = hwidth;
                             overlapExtents[12] =-hwidth;
                             overlapExtents[13] =-hwidth+m_overlapLimitPhi;
                             break;
                         }
                         case EtaMinus: {
                             if ((m_stripId->layer_disk(thisId) & 1) == 0) {
                                 overlapExtents[ 2] = m_overlapLimitEtaMin;
                                 overlapExtents[ 3] = m_overlapLimitEtaMax;
                             } else {
                                 overlapExtents[ 2] =-m_overlapLimitEtaMax;
                                 overlapExtents[ 3] =-m_overlapLimitEtaMin;
                             }
                             break;
                         }
                         default: {
                             if ((m_stripId->layer_disk(thisId) & 1) == 0) {
                                 overlapExtents[ 4] = -m_overlapLimitEtaMax;
                                 overlapExtents[ 5] = -m_overlapLimitEtaMin;
                             } else {
                                 overlapExtents[ 4] = m_overlapLimitEtaMin;
                                 overlapExtents[ 5] = m_overlapLimitEtaMax;
                             }
                             break;
                         }
                     }
                 }
  
                 // producing and filling space points
                 ATH_CHECK( fillStripSpacePoints(neighbourElements, neighbourClusters, overlapExtents, beamSpotVertex,
                         spacePoints, overlapSpacePoints) );
             }
         }
     return StatusCode::SUCCESS;
     }

◆ updateRange()

void ActsTrk::StripSpacePointFormationTool::updateRange	(	const InDetDD::SiDetectorElement *	element1,
		const InDetDD::SiDetectorElement *	element2,
		double &	stripLengthGapTolerance,
		double &	min,
		double &	max
	)		const

private

Definition at line 540 of file StripSpacePointFormationTool.cxx.

     {
         double dm = offset(element1, element2, stripLengthGapTolerance);
         min -= dm;
         max += dm;
     }

Member Data Documentation

◆ m_allClusters

Gaudi::Property< bool > ActsTrk::StripSpacePointFormationTool::m_allClusters {this, "AllClusters", false, "Process all clusters without limits."}

private

Definition at line 109 of file StripSpacePointFormationTool.h.

◆ m_lorentzAngleTool

ToolHandle<ISiLorentzAngleTool> ActsTrk::StripSpacePointFormationTool::m_lorentzAngleTool

private

Initial value:

{this, "LorentzAngleTool", "",

"Tool to retreive Lorentz angle of SCT"}

Using Lorentz angle tool.

Definition at line 103 of file StripSpacePointFormationTool.h.

◆ m_overlapLimitEtaMax

Gaudi::Property< float > ActsTrk::StripSpacePointFormationTool::m_overlapLimitEtaMax {this, "OverlapLimitEtaMax", 3.0, "High overlap limit for eta-neighbours."}

private

Definition at line 121 of file StripSpacePointFormationTool.h.

◆ m_overlapLimitEtaMin

Gaudi::Property< float > ActsTrk::StripSpacePointFormationTool::m_overlapLimitEtaMin {this, "OverlapLimitEtaMin", 1.68, "Low overlap limit for eta-neighbours."}

private

Definition at line 120 of file StripSpacePointFormationTool.h.

◆ m_overlapLimitOpposite

Gaudi::Property< float > ActsTrk::StripSpacePointFormationTool::m_overlapLimitOpposite {this, "OverlapLimitOpposite", 2.8, "Overlap limit for opposite-neighbour."}

private

Definition at line 118 of file StripSpacePointFormationTool.h.

◆ m_overlapLimitPhi

Gaudi::Property< float > ActsTrk::StripSpacePointFormationTool::m_overlapLimitPhi {this, "OverlapLimitPhi", 5.64, "Overlap limit for phi-neighbours."}

private

Definition at line 119 of file StripSpacePointFormationTool.h.

◆ m_stripGapParameter

Gaudi::Property< float > ActsTrk::StripSpacePointFormationTool::m_stripGapParameter {this, "StripGapParameter", 0.0015, "Recommend 0.001 - 0.0015 for ITK geometry"}

private

Definition at line 124 of file StripSpacePointFormationTool.h.

◆ m_stripId

const SCT_ID* ActsTrk::StripSpacePointFormationTool::m_stripId {}

private

Definition at line 97 of file StripSpacePointFormationTool.h.

◆ m_stripLengthTolerance

Gaudi::Property< float > ActsTrk::StripSpacePointFormationTool::m_stripLengthTolerance {this, "StripLengthTolerance", 0.01}

private

The following are parameters to build the space points.

Definition at line 123 of file StripSpacePointFormationTool.h.

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

Public Member Functions

Private Attributes

Production of space points

Detailed Description

Constructor & Destructor Documentation

◆ StripSpacePointFormationTool()

◆ ~StripSpacePointFormationTool()

Member Function Documentation

◆ correctPolarRange()

◆ fillStripSpacePoints()

◆ getStripEnds()

◆ initialize()

◆ makeStripSpacePoint()

◆ offset()

◆ produceSpacePoints()

◆ updateRange()

Member Data Documentation

◆ m_allClusters

◆ m_lorentzAngleTool

◆ m_overlapLimitEtaMax

◆ m_overlapLimitEtaMin

◆ m_overlapLimitOpposite

◆ m_overlapLimitPhi

◆ m_stripGapParameter

◆ m_stripId

◆ m_stripLengthTolerance