#include <TOBRod.h>

Inheritance diagram for TOBRod:

Public Types
typedef PeriodicBinFinderInZ< float >	BinFinderType

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

typedef BoundSurface::PositionType	PositionType

typedef BoundSurface::RotationType	RotationType

typedef TrajectoryStateOnSurface	TrajectoryState

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...

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

	TOBRod (std::vector< const GeomDet > &innerDets, std::vector< const GeomDet > &outerDets) __attribute__((cold))

	~TOBRod () override __attribute__((cold))

Public Member Functions inherited from DetRod
	GeometricSearchDet (bool doHaveGroups)

virtual const Plane &	specificSurface () const final
	Return the rod surface as a Plane. More...

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

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

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

float	computeWindowSize (const GeomDet *det, const TrajectoryStateOnSurface &tsos, const MeasurementEstimator &est) 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 GeomDet * > &	subRod (int ind) const

Private Attributes
std::vector< const GeomDet * >	theDets

BinFinderType	theInnerBinFinder

std::vector< const GeomDet * >	theInnerDets

ReferenceCountingPointer< Plane >	theInnerPlane

BinFinderType	theOuterBinFinder

std::vector< const GeomDet * >	theOuterDets

ReferenceCountingPointer< Plane >	theOuterPlane

Additional Inherited Members
Protected Member Functions inherited from DetRod
void	setPlane (Plane *plane)
	Set the rod's plane. More...

Protected Attributes inherited from GeometricSearchDet
bool	haveGroups

GeomDetCompatibilityChecker	theCompatibilityChecker

Detailed Description

A concrete implementation for TOB Rod

Definition at line 14 of file TOBRod.h.

Member Typedef Documentation

◆ BinFinderType

typedef PeriodicBinFinderInZ<float> TOBRod::BinFinderType

Definition at line 16 of file TOBRod.h.

Constructor & Destructor Documentation

◆ TOBRod()

TOBRod::TOBRod	(	std::vector< const GeomDet *> &	innerDets,
		std::vector< const GeomDet *> &	outerDets
	)

Definition at line 25 of file TOBRod.cc.

References mps_fire::i, LogDebug, DetRod::setPlane(), jetUpdater_cfi::sort, theDets, theInnerBinFinder, theInnerDets, theInnerPlane, theOuterBinFinder, theOuterDets, and theOuterPlane.

     : DetRod(true), theInnerDets(innerDets), theOuterDets(outerDets) {
   theDets.assign(theInnerDets.begin(), theInnerDets.end());
   theDets.insert(theDets.end(), theOuterDets.begin(), theOuterDets.end());
 
   RodPlaneBuilderFromDet planeBuilder;
   setPlane(planeBuilder(theDets));
   theInnerPlane = planeBuilder(theInnerDets);
   theOuterPlane = planeBuilder(theOuterDets);
 
   sort(theDets.begin(), theDets.end(), DetZLess());
   sort(theInnerDets.begin(), theInnerDets.end(), DetZLess());
   sort(theOuterDets.begin(), theOuterDets.end(), DetZLess());
   theInnerBinFinder = BinFinderType(theInnerDets.begin(), theInnerDets.end());
   theOuterBinFinder = BinFinderType(theOuterDets.begin(), theOuterDets.end());
 
   LogDebug("TkDetLayers") << "==== DEBUG TOBRod =====";
   for (vector<const GeomDet*>::const_iterator i = theInnerDets.begin(); i != theInnerDets.end(); i++) {
     LogDebug("TkDetLayers") << "inner TOBRod's Det pos z,perp,eta,phi: " << (**i).position().z() << " , "
                             << (**i).position().perp() << " , " << (**i).position().eta() << " , "
                             << (**i).position().phi();
   }
 
   for (vector<const GeomDet*>::const_iterator i = theOuterDets.begin(); i != theOuterDets.end(); i++) {
     LogDebug("TkDetLayers") << "outer TOBRod's Det pos z,perp,eta,phi: " << (**i).position().z() << " , "
                             << (**i).position().perp() << " , " << (**i).position().eta() << " , "
                             << (**i).position().phi();
   }
   LogDebug("TkDetLayers") << "==== end DEBUG TOBRod =====";
 }

◆ ~TOBRod()

TOBRod::~TOBRod ( )

override

Definition at line 56 of file TOBRod.cc.

56 {}

Member Function Documentation

◆ addClosest()

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

private

Definition at line 138 of file TOBRod.cc.

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

Referenced by groupedCompatibleDetsV().

                                                         {
   const vector<const GeomDet*>& sRod(subRod(crossing.subLayerIndex()));
   return CompatibleDetToGroupAdder::add(*sRod[crossing.closestDetIndex()], tsos, prop, est, result);
 }

◆ basicComponents()

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

inlineoverridevirtual

Implements GeometricSearchDet.

Definition at line 23 of file TOBRod.h.

References theDets.

23 { return theDets; }

TOBRod::theDets

std::vector< const GeomDet * > theDets

Definition: TOBRod.h:64

◆ compatible()

pair< bool, TrajectoryStateOnSurface > TOBRod::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 62 of file TOBRod.cc.

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

◆ components()

const vector< const GeometricSearchDet * > & TOBRod::components ( ) const

overridevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 58 of file TOBRod.cc.

                                                                   {
   throw DetLayerException("TOBRod doesn't have GeometricSearchDet components");
 }

◆ computeCrossings()

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

private

Definition at line 105 of file TOBRod.cc.

References funct::abs(), PeriodicBinFinderInZ< T >::binIndex(), PeriodicBinFinderInZ< T >::binPosition(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), rho, theInnerBinFinder, theInnerPlane, theOuterBinFinder, theOuterPlane, and TrajectoryStateOnSurface::transverseCurvature().

Referenced by groupedCompatibleDetsV().

                                                                                {
   GlobalPoint startPos(startingState.globalPosition());
   GlobalVector startDir(startingState.globalMomentum());
   double rho(startingState.transverseCurvature());
 
   HelixBarrelPlaneCrossingByCircle crossing(startPos, startDir, rho, propDir);
 
   std::pair<bool, double> outerPath = crossing.pathLength(*theOuterPlane);
   if (!outerPath.first)
     return SubLayerCrossings();
   GlobalPoint gOuterPoint(crossing.position(outerPath.second));
 
   std::pair<bool, double> innerPath = crossing.pathLength(*theInnerPlane);
   if (!innerPath.first)
     return SubLayerCrossings();
   GlobalPoint gInnerPoint(crossing.position(innerPath.second));
 
   int innerIndex = theInnerBinFinder.binIndex(gInnerPoint.z());
   float innerDist = std::abs(theInnerBinFinder.binPosition(innerIndex) - gInnerPoint.z());
   SubLayerCrossing innerSLC(0, innerIndex, gInnerPoint);
 
   int outerIndex = theOuterBinFinder.binIndex(gOuterPoint.z());
   float outerDist = std::abs(theOuterBinFinder.binPosition(outerIndex) - gOuterPoint.z());
   SubLayerCrossing outerSLC(1, outerIndex, gOuterPoint);
 
   if (innerDist < outerDist) {
     return SubLayerCrossings(innerSLC, outerSLC, 0);
   } else {
     return SubLayerCrossings(outerSLC, innerSLC, 1);
   }
 }

◆ computeWindowSize()

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

private

Definition at line 147 of file TOBRod.cc.

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

Referenced by groupedCompatibleDetsV().

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

◆ groupedCompatibleDetsV()

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

overridevirtual

Reimplemented from GeometricSearchDet.

Definition at line 69 of file TOBRod.cc.

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

                                                                        {
   SubLayerCrossings crossings;
   crossings = computeCrossings(tsos, prop.propagationDirection());
   if (!crossings.isValid())
     return;
 
   std::vector<DetGroup> closestResult;
   addClosest(tsos, prop, est, crossings.closest(), closestResult);
   if (closestResult.empty()) {
     std::vector<DetGroup> nextResult;
     addClosest(tsos, prop, est, crossings.other(), nextResult);
     if (nextResult.empty())
       return;
 
     DetGroupElement nextGel(nextResult.front().front());
     int crossingSide = LayerCrossingSide().barrelSide(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);
 
     std::vector<DetGroup> nextResult;
     searchNeighbors(tsos, prop, est, crossings.other(), window, nextResult, true);
 
     int crossingSide = LayerCrossingSide().barrelSide(closestGel.trajectoryState(), prop);
     DetGroupMerger::orderAndMergeTwoLevels(
         std::move(closestResult), std::move(nextResult), result, crossings.closestIndex(), crossingSide);
   }
 }

◆ searchNeighbors()

void TOBRod::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 178 of file TOBRod.cc.

References PVValHelper::add(), SubLayerCrossing::closestDetIndex(), hltL1SingleMuFiltered5_cfi::overlap, SubLayerCrossing::position(), mps_fire::result, SubLayerCrossing::subLayerIndex(), subRod(), svgfig::window(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by groupedCompatibleDetsV().

                                                       {
   const GlobalPoint& gCrossingPos = crossing.position();
 
   const vector<const GeomDet*>& sRod(subRod(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 (gCrossingPos.z() < sRod[closestIndex]->surface().position().z()) {
       posStartIndex = closestIndex;
     } else {
       negStartIndex = closestIndex;
     }
   }
 
   typedef CompatibleDetToGroupAdder Adder;
   for (int idet = negStartIndex; idet >= 0; idet--) {
     if (!overlap(gCrossingPos, *sRod[idet], window))
       break;
     if (!Adder::add(*sRod[idet], tsos, prop, est, result))
       break;
   }
   for (int idet = posStartIndex; idet < static_cast<int>(sRod.size()); idet++) {
     if (!overlap(gCrossingPos, *sRod[idet], window))
       break;
     if (!Adder::add(*sRod[idet], tsos, prop, est, result))
       break;
   }
 }