#include <TECLayer.h>

Inheritance diagram for TECLayer:

Public Member Functions
const std::vector< const GeomDet * > &	basicComponents () const override

const std::vector< const GeometricSearchDet * > &	components () const override __attribute__((cold))
	Returns basic components, if any. More...

void	groupedCompatibleDetsV (const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetGroup > &result) const override __attribute__((hot))

SubDetector	subDetector () const override
	The type of detector (PixelBarrel, PixelEndcap, TIB, TOB, TID, TEC, CSC, DT, RPCBarrel, RPCEndcap) More...

	TECLayer (std::vector< const TECPetal > &innerPetals, std::vector< const TECPetal > &outerPetals) __attribute__((cold))

	~TECLayer () override __attribute__((cold))

Public Member Functions inherited from ForwardDetLayer
std::pair< bool, TrajectoryStateOnSurface >	compatible (const TrajectoryStateOnSurface &, const Propagator &, const MeasurementEstimator &) const override

bool	contains (const Local3DPoint &p) const

	ForwardDetLayer (bool doHaveGroups)

Location	location () const final
	Which part of the detector (barrel, endcap) More...

virtual const BoundDisk &	specificSurface () const final

const BoundSurface &	surface () const final
	The surface of the GeometricSearchDet. More...

	~ForwardDetLayer () override

Public Member Functions inherited from DetLayer
	DetLayer (bool doHaveGroup, bool ibar)

bool	isBarrel () const

bool	isForward () const

int	seqNum () const

void	setSeqNum (int sq)

	~DetLayer () override

Public Member Functions inherited from GeometricSearchDet
virtual std::vector< DetWithState >	compatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const

virtual void	compatibleDetsV (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetWithState > &result) const

	GeometricSearchDet (bool doHaveGroups)

virtual std::vector< DetGroup >	groupedCompatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const

bool	hasGroups () const

virtual const Surface::PositionType &	position () const
	Returns position of the surface. More...

virtual	~GeometricSearchDet ()

Protected Types
typedef PeriodicBinFinderInPhi< float >	BinFinderPhi

Protected Attributes
BinFinderPhi	theBackBinFinder

std::vector< const TECPetal * >	theBackComps

ReferenceCountingPointer< BoundDisk >	theBackDisk

std::vector< const GeomDet * >	theBasicComps

std::vector< const GeometricSearchDet * >	theComps

BinFinderPhi	theFrontBinFinder

std::vector< const TECPetal * >	theFrontComps

ReferenceCountingPointer< BoundDisk >	theFrontDisk

Protected Attributes inherited from GeometricSearchDet
bool	haveGroups

GeomDetCompatibilityChecker	theCompatibilityChecker

Private Member Functions
bool	addClosest (const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, const SubLayerCrossing &crossing, std::vector< DetGroup > &result) const __attribute__((hot))

SubLayerCrossings	computeCrossings (const TrajectoryStateOnSurface &startingState, PropagationDirection propDir) const __attribute__((hot))

void	searchNeighbors (const TrajectoryStateOnSurface &tsos, const Propagator &prop, const MeasurementEstimator &est, const SubLayerCrossing &crossing, float window, std::vector< DetGroup > &result, bool checkClosest) const __attribute__((hot))

const std::vector< const TECPetal * > &	subLayer (int ind) const

Additional Inherited Members
Public Types inherited from DetLayer
typedef GeomDetEnumerators::Location	Location

typedef GeomDetEnumerators::SubDetector	SubDetector

Public Types inherited from GeometricSearchDet
typedef std::pair< const GeomDet *, TrajectoryStateOnSurface >	DetWithState

typedef BoundSurface::PositionType	PositionType

typedef BoundSurface::RotationType	RotationType

typedef TrajectoryStateOnSurface	TrajectoryState

Protected Member Functions inherited from ForwardDetLayer
SimpleDiskBounds const &	bounds () const

virtual BoundDisk *	computeSurface ()

virtual void	initialize ()

float	rmax () const

float	rmin () const

void	setSurface (BoundDisk *cp)

float	zmax () const

float	zmin () const

Detailed Description

A concrete implementation for TEC layer built out of TECPetals

Definition at line 15 of file TECLayer.h.

Member Typedef Documentation

◆ BinFinderPhi

typedef PeriodicBinFinderInPhi<float> TECLayer::BinFinderPhi

protected

Definition at line 65 of file TECLayer.h.

Constructor & Destructor Documentation

◆ TECLayer()

TECLayer::TECLayer	(	std::vector< const TECPetal *> &	innerPetals,
		std::vector< const TECPetal *> &	outerPetals
	)

Definition at line 50 of file TECLayer.cc.

References tkDetUtil::computeDisk(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, LogDebug, PV3DBase< T, PVType, FrameType >::perp(), GeometricSearchDet::position(), ForwardDetLayer::setSurface(), ForwardDetLayer::specificSurface(), theBackBinFinder, theBackComps, theBackDisk, theBasicComps, theComps, theFrontBinFinder, theFrontComps, theFrontDisk, and PV3DBase< T, PVType, FrameType >::z().

     : ForwardDetLayer(true),
       theFrontComps(innerPetals.begin(), innerPetals.end()),
       theBackComps(outerPetals.begin(), outerPetals.end()) {
   theComps.assign(theFrontComps.begin(), theFrontComps.end());
   theComps.insert(theComps.end(), theBackComps.begin(), theBackComps.end());
 
   for (vector<const GeometricSearchDet*>::const_iterator it = theComps.begin(); it != theComps.end(); it++) {
     theBasicComps.insert(theBasicComps.end(), (**it).basicComponents().begin(), (**it).basicComponents().end());
   }
 
   //This should be no necessary. TO BE CHECKED
   //sort(theFrontPetals.begin(), theFrontPetals.end(), PetalLessPhi());
   //sort(theBackPetals.begin(), theBackPetals.end(), PetalLessPhi());
 
   // building disk for front and back petals
   setSurface(computeDisk(theComps));
   theFrontDisk = computeDisk(theFrontComps);
   theBackDisk = computeDisk(theBackComps);
 
   // set up the bin finders
   theFrontBinFinder = BinFinderPhi(theFrontComps.front()->position().phi(), theFrontComps.size());
   theBackBinFinder = BinFinderPhi(theBackComps.front()->position().phi(), theBackComps.size());
 
   //--------- DEBUG INFO --------------
   LogDebug("TkDetLayers") << "DEBUG INFO for TECLayer"
                           << "\n"
                           << "TECLayer z,perp, innerRadius, outerR: " << this->position().z() << " , "
                           << this->position().perp() << " , " << this->specificSurface().innerRadius() << " , "
                           << this->specificSurface().outerRadius();
 
   for (auto it = theFrontComps.begin(); it != theFrontComps.end(); it++) {
     LogDebug("TkDetLayers") << "frontPetal phi,z,r: " << (*it)->surface().position().phi() << " , "
                             << (*it)->surface().position().z() << " , " << (*it)->surface().position().perp();
   }
 
   for (auto it = theBackComps.begin(); it != theBackComps.end(); it++) {
     LogDebug("TkDetLayers") << "backPetal phi,z,r: " << (*it)->surface().position().phi() << " , "
                             << (*it)->surface().position().z() << " , " << (*it)->surface().position().perp();
   }
   //-----------------------------------
 }

◆ ~TECLayer()

TECLayer::~TECLayer ( )

override

Definition at line 93 of file TECLayer.cc.

References mps_fire::i, and theComps.

                     {
   for (auto i = theComps.begin(); i != theComps.end(); i++) {
     delete *i;
   }
 }

Member Function Documentation

◆ addClosest()

bool TECLayer::addClosest	(	const TrajectoryStateOnSurface &	tsos,
		const Propagator &	prop,
		const MeasurementEstimator &	est,
		const SubLayerCrossing &	crossing,
		std::vector< DetGroup > &	result
	)		const

private

Definition at line 179 of file TECLayer.cc.

References CompatibleDetToGroupAdder::add(), SubLayerCrossing::closestDetIndex(), LogDebug, mps_fire::result, subLayer(), and SubLayerCrossing::subLayerIndex().

Referenced by groupedCompatibleDetsV().

                                                           {
   const auto& sub(subLayer(crossing.subLayerIndex()));
   const auto det(sub[crossing.closestDetIndex()]);
 
   LogDebug("TkDetLayers") << "in TECLayer, adding petal at r,z,phi: (" << det->position().perp() << ","
                           << det->position().z() << "," << det->position().phi() << ")" << endl;
 
   return CompatibleDetToGroupAdder().add(*det, tsos, prop, est, result);
 }

◆ basicComponents()

const std::vector<const GeomDet*>& TECLayer::basicComponents ( ) const

inlineoverridevirtual

Implements GeometricSearchDet.

Definition at line 22 of file TECLayer.h.

References theBasicComps.

22 { return theBasicComps; }

TECLayer::theBasicComps

std::vector< const GeomDet * > theBasicComps

Definition: TECLayer.h:57

◆ components()

const std::vector<const GeometricSearchDet*>& TECLayer::components ( ) const

inlineoverridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 24 of file TECLayer.h.

References theComps.

24 { return theComps; }

TECLayer::theComps

std::vector< const GeometricSearchDet * > theComps

Definition: TECLayer.h:56

◆ computeCrossings()

SubLayerCrossings TECLayer::computeCrossings	(	const TrajectoryStateOnSurface &	startingState,
		PropagationDirection	propDir
	)		const

private

Definition at line 137 of file TECLayer.cc.

References funct::abs(), PeriodicBinFinderInPhi< T >::binIndex(), SiPixelRawToDigiRegional_cfi::deltaPhi, TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), LogDebug, rho, theBackBinFinder, theBackComps, theBackDisk, theFrontBinFinder, theFrontComps, theFrontDisk, and TrajectoryStateOnSurface::transverseCurvature().

Referenced by groupedCompatibleDetsV().

                                                                                  {
   double rho(startingState.transverseCurvature());
 
   HelixPlaneCrossing::PositionType startPos(startingState.globalPosition());
   HelixPlaneCrossing::DirectionType startDir(startingState.globalMomentum());
   HelixForwardPlaneCrossing crossing(startPos, startDir, rho, propDir);
 
   pair<bool, double> frontPath = crossing.pathLength(*theFrontDisk);
   if (!frontPath.first)
     return SubLayerCrossings();
 
   GlobalPoint gFrontPoint(crossing.position(frontPath.second));
 
   LogDebug("TkDetLayers") << "in TECLayer,front crossing point: r,z,phi: (" << gFrontPoint.perp() << ","
                           << gFrontPoint.z() << "," << gFrontPoint.phi() << ")" << endl;
 
   int frontIndex = theFrontBinFinder.binIndex(gFrontPoint.barePhi());
   SubLayerCrossing frontSLC(0, frontIndex, gFrontPoint);
 
   pair<bool, double> backPath = crossing.pathLength(*theBackDisk);
   if (!backPath.first)
     return SubLayerCrossings();
 
   GlobalPoint gBackPoint(crossing.position(backPath.second));
   LogDebug("TkDetLayers") << "in TECLayer,back crossing point: r,z,phi: (" << gBackPoint.perp() << ","
                           << gFrontPoint.z() << "," << gBackPoint.phi() << ")" << endl;
 
   int backIndex = theBackBinFinder.binIndex(gBackPoint.barePhi());
   SubLayerCrossing backSLC(1, backIndex, gBackPoint);
 
   // 0ss: frontDisk has index=0, backDisk has index=1
   float frontDist = std::abs(Geom::deltaPhi(gFrontPoint.barePhi(), theFrontComps[frontIndex]->surface().phi()));
   float backDist = std::abs(Geom::deltaPhi(gBackPoint.barePhi(), theBackComps[backIndex]->surface().phi()));
 
   if (frontDist < backDist) {
     return SubLayerCrossings(frontSLC, backSLC, 0);
   } else {
     return SubLayerCrossings(backSLC, frontSLC, 1);
   }
 }

◆ groupedCompatibleDetsV()

void TECLayer::groupedCompatibleDetsV	(	const TrajectoryStateOnSurface &	tsos,
		const Propagator &	prop,
		const MeasurementEstimator &	est,
		std::vector< DetGroup > &	result
	)		const

overridevirtual

Reimplemented from GeometricSearchDet.

Definition at line 99 of file TECLayer.cc.

References addClosest(), SubLayerCrossings::closest(), SubLayerCrossings::closestIndex(), computeCrossings(), tkDetUtil::computeWindowSize(), LayerCrossingSide::endcapSide(), SubLayerCrossings::isValid(), LogDebug, eostools::move(), DetGroupMerger::orderAndMergeTwoLevels(), SubLayerCrossings::other(), trackingPOGFilters_cfi::phiWindow, Propagator::propagationDirection(), mps_fire::result, and searchNeighbors().

                                                                          {
   SubLayerCrossings crossings;
   crossings = computeCrossings(tsos, prop.propagationDirection());
   if (!crossings.isValid())
     return;
 
   vector<DetGroup> closestResult;
   addClosest(tsos, prop, est, crossings.closest(), closestResult);
   LogDebug("TkDetLayers") << "in TECLayer, closestResult.size(): " << closestResult.size();
 
   // this differs from other groupedCompatibleDets logic, which DON'T check next in such cases!!!
   if (closestResult.empty()) {
     vector<DetGroup> nextResult;
     addClosest(tsos, prop, est, crossings.other(), nextResult);
     LogDebug("TkDetLayers") << "in TECLayer, nextResult.size(): " << nextResult.size();
     if (nextResult.empty())
       return;
 
     DetGroupElement nextGel(nextResult.front().front());
     int crossingSide = LayerCrossingSide::endcapSide(nextGel.trajectoryState(), prop);
     DetGroupMerger::orderAndMergeTwoLevels(
         std::move(closestResult), std::move(nextResult), result, crossings.closestIndex(), crossingSide);
   } else {
     DetGroupElement closestGel(closestResult.front().front());
     float phiWindow = tkDetUtil::computeWindowSize(closestGel.det(), closestGel.trajectoryState(), est);
     searchNeighbors(tsos, prop, est, crossings.closest(), phiWindow, closestResult, false);
     vector<DetGroup> nextResult;
     searchNeighbors(tsos, prop, est, crossings.other(), phiWindow, nextResult, true);
 
     int crossingSide = LayerCrossingSide::endcapSide(closestGel.trajectoryState(), prop);
     DetGroupMerger::orderAndMergeTwoLevels(
         std::move(closestResult), std::move(nextResult), result, crossings.closestIndex(), crossingSide);
   }
 }

◆ searchNeighbors()

void TECLayer::searchNeighbors	(	const TrajectoryStateOnSurface &	tsos,
		const Propagator &	prop,
		const MeasurementEstimator &	est,
		const SubLayerCrossing &	crossing,
		float	window,
		std::vector< DetGroup > &	result,
		bool	checkClosest
	)		const

private

Definition at line 205 of file TECLayer.cc.

References PVValHelper::add(), PV3DBase< T, PVType, FrameType >::barePhi(), PeriodicBinFinderInPhi< T >::binIndex(), SubLayerCrossing::closestDetIndex(), hltL1SingleMuFiltered5_cfi::overlap, phi, Geom::phiLess(), SubLayerCrossing::position(), mps_fire::result, subLayer(), SubLayerCrossing::subLayerIndex(), ForwardDetLayer::surface(), theBackBinFinder, theFrontBinFinder, and svgfig::window().

Referenced by groupedCompatibleDetsV().

                                                         {
   const GlobalPoint& gCrossingPos = crossing.position();
   auto gphi = gCrossingPos.barePhi();
 
   const auto& sLayer(subLayer(crossing.subLayerIndex()));
 
   int closestIndex = crossing.closestDetIndex();
   int negStartIndex = closestIndex - 1;
   int posStartIndex = closestIndex + 1;
 
   if (checkClosest) {  // must decide if the closest is on the neg or pos side
     if (Geom::phiLess(gphi, sLayer[closestIndex]->surface().phi())) {
       posStartIndex = closestIndex;
     } else {
       negStartIndex = closestIndex;
     }
   }
 
   const BinFinderPhi& binFinder = (crossing.subLayerIndex() == 0 ? theFrontBinFinder : theBackBinFinder);
 
   typedef CompatibleDetToGroupAdder Adder;
   int half = sLayer.size() / 2;  // to check if dets are called twice....
   for (int idet = negStartIndex; idet >= negStartIndex - half; idet--) {
     const auto& neighborPetal = *sLayer[binFinder.binIndex(idet)];
     if (!overlap(gphi, neighborPetal, window))
       break;
     if (!Adder::add(neighborPetal, tsos, prop, est, result))
       break;
     // maybe also add shallow crossing angle test here???
   }
   for (int idet = posStartIndex; idet < posStartIndex + half; idet++) {
     const auto& neighborPetal = *sLayer[binFinder.binIndex(idet)];
     if (!overlap(gphi, neighborPetal, window))
       break;
     if (!Adder::add(neighborPetal, tsos, prop, est, result))
       break;
     // maybe also add shallow crossing angle test here???
   }
 }