#include <CompositeTECPetal.h>

Inheritance diagram for CompositeTECPetal:

Classes
struct	WedgePar

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

std::pair< bool, TrajectoryStateOnSurface >	compatible (const TrajectoryStateOnSurface &ts, const Propagator &, const MeasurementEstimator &) const override __attribute__((cold))

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

	CompositeTECPetal (std::vector< const TECWedge > &innerWedges, std::vector< const TECWedge > &outerWedges) __attribute__((cold))

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

virtual const BoundDiskSector &	specificSurface () const final

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

	~CompositeTECPetal () override __attribute__((cold))

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

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 &tsos, PropagationDirection propDir) const __attribute__((hot))

int	findBin (float R, int layer) const

WedgePar const &	findPar (int index, int diskSectorType) const

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 TECWedge * > &	subLayer (int ind) const

Static Private Member Functions
static float	computeWindowSize (const GeomDet *det, const TrajectoryStateOnSurface &tsos, const MeasurementEstimator &est) __attribute__((hot))

Private Attributes
std::vector< float >	theBackBoundaries

std::vector< const TECWedge * >	theBackComps

std::vector< WedgePar >	theBackPars

ReferenceCountingPointer< BoundDiskSector >	theBackSector

std::vector< const GeomDet * >	theBasicComps

std::vector< const GeometricSearchDet * >	theComps

ReferenceCountingPointer< BoundDiskSector >	theDiskSector

std::vector< float >	theFrontBoundaries

std::vector< const TECWedge * >	theFrontComps

std::vector< WedgePar >	theFrontPars

ReferenceCountingPointer< BoundDiskSector >	theFrontSector

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

typedef BoundSurface::PositionType	PositionType

typedef BoundSurface::RotationType	RotationType

typedef TrajectoryStateOnSurface	TrajectoryState

Protected Attributes inherited from GeometricSearchDet
bool	haveGroups

GeomDetCompatibilityChecker	theCompatibilityChecker

Detailed Description

A concrete implementation for TEC petals

Definition at line 18 of file CompositeTECPetal.h.

Constructor & Destructor Documentation

◆ CompositeTECPetal()

CompositeTECPetal::CompositeTECPetal	(	std::vector< const TECWedge *> &	innerWedges,
		std::vector< const TECWedge *> &	outerWedges
	)

Definition at line 80 of file CompositeTECPetal.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, LogDebug, theBackBoundaries, theBackComps, theBackPars, theBackSector, theBasicComps, theComps, theDiskSector, theFrontBoundaries, theFrontComps, theFrontPars, and theFrontSector.

     : GeometricSearchDet(true), theFrontComps(innerWedges), theBackComps(outerWedges) {
   theComps.assign(theFrontComps.begin(), theFrontComps.end());
   theComps.insert(theComps.end(), theBackComps.begin(), theBackComps.end());
 
   details::fillBoundaries(theFrontComps, theFrontBoundaries);
   details::fillBoundaries(theBackComps, theBackBoundaries);
   details::fillPars(theFrontComps, theFrontPars);
   details::fillPars(theBackComps, theBackPars);
 
   for (vector<const GeometricSearchDet*>::const_iterator it = theComps.begin(); it != theComps.end(); it++) {
     theBasicComps.insert(theBasicComps.end(), (**it).basicComponents().begin(), (**it).basicComponents().end());
   }
 
   //the Wedge are already R ordered
   //sort( theWedges.begin(), theWedges.end(), DetLessR());
   //sort( theFrontWedges.begin(), theFrontWedges.end(), DetLessR() );
   //sort( theBackWedges.begin(), theBackWedges.end(), DetLessR() );
   vector<const TECWedge*> allWedges;
   allWedges.assign(innerWedges.begin(), innerWedges.end());
   allWedges.insert(allWedges.end(), outerWedges.begin(), outerWedges.end());
 
   theDiskSector = ForwardDiskSectorBuilderFromWedges()(allWedges);
   theFrontSector = ForwardDiskSectorBuilderFromWedges()(innerWedges);
   theBackSector = ForwardDiskSectorBuilderFromWedges()(outerWedges);
 
   //--------- DEBUG INFO --------------
   LogDebug("TkDetLayers") << "DEBUG INFO for CompositeTECPetal";
 
   for (auto it = theFrontComps.begin(); it != theFrontComps.end(); it++) {
     LogDebug("TkDetLayers") << "frontWedge 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") << "backWedge phi,z,r: " << (*it)->surface().position().phi() << " , "
                             << (*it)->surface().position().z() << " , " << (*it)->surface().position().perp();
   }
   //-----------------------------------
 }

◆ ~CompositeTECPetal()

CompositeTECPetal::~CompositeTECPetal ( )

override

Definition at line 121 of file CompositeTECPetal.cc.

References mps_fire::i, and theComps.

                                       {
   vector<const GeometricSearchDet*>::const_iterator i;
   for (i = theComps.begin(); i != theComps.end(); i++) {
     delete *i;
   }
 }

Member Function Documentation

◆ addClosest()

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

private

Definition at line 217 of file CompositeTECPetal.cc.

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

Referenced by groupedCompatibleDetsV().

                                                                    {
   auto det = subLayer(crossing.subLayerIndex())[crossing.closestDetIndex()];
 
   LogDebug("TkDetLayers") << "in TECPetal, adding Wedge at r,z,phi: (" << det->position().perp() << ","
                           << det->position().z() << "," << det->position().phi() << ")";
   LogDebug("TkDetLayers") << "wedge comps size: " << det->basicComponents().size();
 
   return CompatibleDetToGroupAdder::add(*det, tsos, prop, est, result);
 }

◆ basicComponents()

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

inlineoverridevirtual

Implements GeometricSearchDet.

Definition at line 35 of file CompositeTECPetal.h.

References theBasicComps.

35 { return theBasicComps; }

CompositeTECPetal::theBasicComps

std::vector< const GeomDet * > theBasicComps

Definition: CompositeTECPetal.h:85

◆ compatible()

pair< bool, TrajectoryStateOnSurface > CompositeTECPetal::compatible	(	const TrajectoryStateOnSurface &	ts,
		const Propagator &	,
		const MeasurementEstimator &
	)		const

overridevirtual

tests the geometrical compatibility of the Det with the predicted state. The FreeTrajectoryState argument is propagated to the Det surface using the Propagator argument. The resulting TrajectoryStateOnSurface is tested for compatibility with the surface bounds. If compatible, a std::pair< true, propagatedState> is returned. If the propagation fails, or if the state is not compatible, a std::pair< false, propagatedState> is returned.

Implements GeometricSearchDet.

Definition at line 128 of file CompositeTECPetal.cc.

                                                                                                       {
   edm::LogError("TkDetLayers") << "temporary dummy implementation of CompositeTECPetal::compatible()!!";
   return pair<bool, TrajectoryStateOnSurface>();
 }

◆ components()

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

inlineoverridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 37 of file CompositeTECPetal.h.

References theComps.

37 { return theComps; }

CompositeTECPetal::theComps

std::vector< const GeometricSearchDet * > theComps

Definition: CompositeTECPetal.h:86

◆ computeCrossings()

SubLayerCrossings CompositeTECPetal::computeCrossings	(	const TrajectoryStateOnSurface &	tsos,
		PropagationDirection	propDir
	)		const

private

Definition at line 174 of file CompositeTECPetal.cc.

References funct::abs(), findBin(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), LogDebug, HelixForwardPlaneCrossing::pathLength(), HelixForwardPlaneCrossing::position(), rho, theBackPars, theBackSector, theFrontPars, theFrontSector, and TrajectoryStateOnSurface::transverseCurvature().

Referenced by groupedCompatibleDetsV().

                                                                                           {
   HelixPlaneCrossing::PositionType startPos(startingState.globalPosition());
   HelixPlaneCrossing::DirectionType startDir(startingState.globalMomentum());
 
   auto rho = startingState.transverseCurvature();
 
   HelixForwardPlaneCrossing crossing(startPos, startDir, rho, propDir);
 
   pair<bool, double> frontPath = crossing.pathLength(*theFrontSector);
   if (!frontPath.first)
     return SubLayerCrossings();
 
   pair<bool, double> backPath = crossing.pathLength(*theBackSector);
   if (!backPath.first)
     return SubLayerCrossings();
 
   GlobalPoint gFrontPoint(crossing.position(frontPath.second));
   GlobalPoint gBackPoint(crossing.position(backPath.second));
 
   LogDebug("TkDetLayers") << "in TECPetal,front crossing : r,z,phi: (" << gFrontPoint.perp() << "," << gFrontPoint.z()
                           << "," << gFrontPoint.phi() << ")";
 
   LogDebug("TkDetLayers") << "in TECPetal,back crossing r,z,phi: (" << gBackPoint.perp() << "," << gBackPoint.z() << ","
                           << gBackPoint.phi() << ")";
 
   int frontIndex = findBin(gFrontPoint.perp(), 0);
   SubLayerCrossing frontSLC(0, frontIndex, gFrontPoint);
 
   int backIndex = findBin(gBackPoint.perp(), 1);
   SubLayerCrossing backSLC(1, backIndex, gBackPoint);
 
   auto frontDist = std::abs(theFrontPars[frontIndex].theR - gFrontPoint.perp());
   auto backDist = std::abs(theBackPars[backIndex].theR - gBackPoint.perp());
 
   // 0ss: frontDisk has index=0, backDisk has index=1
   if (frontDist < backDist) {
     return SubLayerCrossings(frontSLC, backSLC, 0);
   } else {
     return SubLayerCrossings(backSLC, frontSLC, 1);
   }
 }

◆ computeWindowSize()

float CompositeTECPetal::computeWindowSize	(	const GeomDet *	det,
		const TrajectoryStateOnSurface &	tsos,
		const MeasurementEstimator &	est
	)

staticprivate

Definition at line 282 of file CompositeTECPetal.cc.

References MeasurementEstimator::maximalLocalDisplacement(), GeomDet::surface(), and y.

Referenced by groupedCompatibleDetsV().

                                                                             {
   return est.maximalLocalDisplacement(tsos, det->surface()).y();
 }

◆ findBin()

int CompositeTECPetal::findBin	(	float	R,
		int	layer
	)		const

private

Definition at line 288 of file CompositeTECPetal.cc.

References dttmaxenums::R, theBackBoundaries, and theFrontBoundaries.

Referenced by computeCrossings().

                                                                 {
   return details::findBin(diskSectorType == 0 ? theFrontBoundaries : theBackBoundaries, R);
 }

◆ findPar()

WedgePar const& CompositeTECPetal::findPar	(	int	index,
		int	diskSectorType
	)		const

inlineprivate

Definition at line 76 of file CompositeTECPetal.h.

References theBackPars, and theFrontPars.

Referenced by searchNeighbors().

                                                                             {
     return (diskSectorType == 0) ? theFrontPars[index] : theBackPars[index];
   }

◆ groupedCompatibleDetsV()

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

overridevirtual

Reimplemented from GeometricSearchDet.

Definition at line 135 of file CompositeTECPetal.cc.

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

                                                                                   {
   vector<DetGroup> closestResult;
   SubLayerCrossings crossings;
   crossings = computeCrossings(tsos, prop.propagationDirection());
   if (!crossings.isValid())
     return;
 
   addClosest(tsos, prop, est, crossings.closest(), closestResult);
   LogDebug("TkDetLayers") << "in TECPetal, closestResult.size(): " << closestResult.size();
 
   if (closestResult.empty()) {
     vector<DetGroup> nextResult;
     addClosest(tsos, prop, est, crossings.other(), nextResult);
     LogDebug("TkDetLayers") << "in TECPetal, 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 window = computeWindowSize(closestGel.det(), closestGel.trajectoryState(), est);
 
     searchNeighbors(tsos, prop, est, crossings.closest(), window, closestResult, false);
 
     vector<DetGroup> nextResult;
     searchNeighbors(tsos, prop, est, crossings.other(), window, nextResult, true);
 
     int crossingSide = LayerCrossingSide::endcapSide(closestGel.trajectoryState(), prop);
     DetGroupMerger::orderAndMergeTwoLevels(
         std::move(closestResult), std::move(nextResult), result, crossings.closestIndex(), crossingSide);
   }
 }

◆ searchNeighbors()

void CompositeTECPetal::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 231 of file CompositeTECPetal.cc.

References PVValHelper::add(), SubLayerCrossing::closestDetIndex(), findPar(), hltL1SingleMuFiltered5_cfi::overlap, PV3DBase< T, PVType, FrameType >::perp2(), SubLayerCrossing::position(), mps_fire::result, subLayer(), SubLayerCrossing::subLayerIndex(), theBackComps, theFrontComps, and svgfig::window().

Referenced by groupedCompatibleDetsV().

                                                                  {
   const GlobalPoint& gCrossingPos = crossing.position();
 
   int closestIndex = crossing.closestDetIndex();
   int negStartIndex = closestIndex - 1;
   int posStartIndex = closestIndex + 1;
 
   float detR = findPar(closestIndex, crossing.subLayerIndex()).theR;
 
   if (checkClosest) {  // must decide if the closest is on the neg or pos side
     if (gCrossingPos.perp2() < detR * detR) {
       posStartIndex = closestIndex;
     } else {
       negStartIndex = closestIndex;
     }
   }
 
   const std::vector<const TECWedge*>& sLayer = subLayer(crossing.subLayerIndex());
 
   //const BinFinderType& binFinder = (crossing.subLayerIndex()==0 ? theFrontBinFinder : theBackBinFinder);
   int theSize = crossing.subLayerIndex() == 0 ? theFrontComps.size() : theBackComps.size();
 
   typedef CompatibleDetToGroupAdder Adder;
   for (int idet = negStartIndex; idet >= 0; idet--) {
     //if(idet<0 || idet>= theSize) {edm::LogInfo(TkDetLayers) << "===== error! gone out vector bounds.idet: " << idet ;exit;}
     const GeometricSearchDet& neighborWedge = *sLayer[idet];
     WedgePar const& wpar = findPar(idet, crossing.subLayerIndex());
     if (!details::overlap(gCrossingPos, wpar, window))
       break;  // --- to check
     if (!Adder::add(neighborWedge, tsos, prop, est, result))
       break;
     // maybe also add shallow crossing angle test here???
   }
   for (int idet = posStartIndex; idet < theSize; idet++) {
     //if(idet<0 || idet>= theSize) {edm::LogInfo(TkDetLayers) << "===== error! gone out vector bounds.idet: " << idet ;exit;}
     const GeometricSearchDet& neighborWedge = *sLayer[idet];
     WedgePar const& wpar = findPar(idet, crossing.subLayerIndex());
     if (!details::overlap(gCrossingPos, wpar, window))
       break;  // ---- to check
     if (!Adder::add(neighborWedge, tsos, prop, est, result))
       break;
     // maybe also add shallow crossing angle test here???
   }
 }

◆ specificSurface()

virtual const BoundDiskSector& CompositeTECPetal::specificSurface ( ) const

inlinefinalvirtual

Definition at line 32 of file CompositeTECPetal.h.

References theDiskSector.

32 { return *theDiskSector; }

CompositeTECPetal::theDiskSector

ReferenceCountingPointer< BoundDiskSector > theDiskSector

Definition: CompositeTECPetal.h:50

◆ subLayer()

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

inlineprivate

Definition at line 80 of file CompositeTECPetal.h.

References theBackComps, and theFrontComps.

Referenced by addClosest(), and searchNeighbors().

                                                                          {
     return (ind == 0 ? theFrontComps : theBackComps);
   }

◆ surface()

const BoundSurface& CompositeTECPetal::surface ( ) const

inlinefinalvirtual

The surface of the GeometricSearchDet.

Implements GeometricSearchDet.

Definition at line 30 of file CompositeTECPetal.h.

References theDiskSector.

30 { return *theDiskSector; }

CompositeTECPetal::theDiskSector

ReferenceCountingPointer< BoundDiskSector > theDiskSector

Definition: CompositeTECPetal.h:50

Member Data Documentation

◆ theBackBoundaries

std::vector<float> CompositeTECPetal::theBackBoundaries

private

Definition at line 92 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), and findBin().

◆ theBackComps

std::vector<const TECWedge*> CompositeTECPetal::theBackComps

private

Definition at line 89 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), searchNeighbors(), and subLayer().

◆ theBackPars

std::vector<WedgePar> CompositeTECPetal::theBackPars

private

Definition at line 94 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), computeCrossings(), and findPar().

◆ theBackSector

ReferenceCountingPointer<BoundDiskSector> CompositeTECPetal::theBackSector

private

Definition at line 97 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), and computeCrossings().

◆ theBasicComps

std::vector<const GeomDet*> CompositeTECPetal::theBasicComps

private

Definition at line 85 of file CompositeTECPetal.h.

Referenced by basicComponents(), and CompositeTECPetal().

◆ theComps

std::vector<const GeometricSearchDet*> CompositeTECPetal::theComps

private

Definition at line 86 of file CompositeTECPetal.h.

Referenced by components(), CompositeTECPetal(), and ~CompositeTECPetal().

◆ theDiskSector

ReferenceCountingPointer<BoundDiskSector> CompositeTECPetal::theDiskSector

private

Definition at line 50 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), specificSurface(), and surface().

◆ theFrontBoundaries

std::vector<float> CompositeTECPetal::theFrontBoundaries

private

Definition at line 91 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), and findBin().

◆ theFrontComps

std::vector<const TECWedge*> CompositeTECPetal::theFrontComps

private

Definition at line 88 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), searchNeighbors(), and subLayer().

◆ theFrontPars

std::vector<WedgePar> CompositeTECPetal::theFrontPars

private

Definition at line 93 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), computeCrossings(), and findPar().

◆ theFrontSector

ReferenceCountingPointer<BoundDiskSector> CompositeTECPetal::theFrontSector

private

Definition at line 96 of file CompositeTECPetal.h.

Referenced by CompositeTECPetal(), and computeCrossings().

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CompositeTECPetal()

◆ ~CompositeTECPetal()

Member Function Documentation

◆ addClosest()

◆ basicComponents()

◆ compatible()

◆ components()

◆ computeCrossings()

◆ computeWindowSize()

◆ findBin()

◆ findPar()

◆ groupedCompatibleDetsV()

◆ searchNeighbors()

◆ specificSurface()

◆ subLayer()

◆ surface()

Member Data Documentation

◆ theBackBoundaries

◆ theBackComps

◆ theBackPars

◆ theBackSector

◆ theBasicComps

◆ theComps

◆ theDiskSector

◆ theFrontBoundaries

◆ theFrontComps

◆ theFrontPars

◆ theFrontSector