#include <TIBLayer.h>

Inheritance diagram for TIBLayer:

Public Member Functions
	TIBLayer (std::vector< const TIBRing > &innerRings, std::vector< const TIBRing > &outerRings) __attribute__((cold))

	~TIBLayer () override __attribute__((cold))

Public Member Functions inherited from TBLayer
const std::vector< const GeomDet * > &	basicComponents () const final

const std::vector< const GeometricSearchDet * > &	components () const final __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 final
	The type of detector (PixelBarrel, PixelEndcap, TIB, TOB, TID, TEC, CSC, DT, RPCBarrel, RPCEndcap) More...

template<typename TDET >
	TBLayer (std::vector< const TDET > &inner, std::vector< const TDET > &outer, GeomDetEnumerators::SubDetector ime)

	~TBLayer () override __attribute__((cold))

Public Member Functions inherited from BarrelDetLayer
	BarrelDetLayer (bool doHaveGroup)

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

bool	contains (const Local3DPoint &p) const

Location	location () const final
	DetLayer interface. More...

virtual const BoundCylinder &	specificSurface () const final
	Extension of the interface. More...

const BoundSurface &	surface () const final
	GeometricSearchDet interface. More...

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

Private Member Functions
std::tuple< bool, int, int >	computeIndexes (GlobalPoint gInnerPoint, GlobalPoint gOuterPoint) const override __attribute__((hot))

float	computeWindowSize (const GeomDet *det, const TrajectoryStateOnSurface &tsos, const MeasurementEstimator &est) const override __attribute__((hot))

BoundCylinder *	cylinder (const std::vector< const GeometricSearchDet *> &rings) __attribute__((cold))

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

Static Private Member Functions
static bool	overlap (const GlobalPoint &gpos, const GeometricSearchDet &ring, float window) __attribute__((hot))

Private Attributes
GeneralBinFinderInZforGeometricSearchDet< float >	theInnerBinFinder

GeneralBinFinderInZforGeometricSearchDet< float >	theOuterBinFinder

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

bool	isPhase2OT () const

bool	isPixel () const

bool	isTIB () const

bool	isTOB () const

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

Protected Member Functions inherited from BarrelDetLayer
SimpleCylinderBounds const &	bounds () const

virtual BoundCylinder *	computeSurface ()

virtual void	initialize ()

void	setSurface (BoundCylinder *cp)

Protected Attributes inherited from TBLayer
GeomDetEnumerators::SubDetector	me

std::vector< const GeomDet * >	theBasicComps

std::vector< const GeometricSearchDet * >	theComps

std::vector< const GeometricSearchDet * >	theInnerComps

ReferenceCountingPointer< BoundCylinder >	theInnerCylinder

std::vector< const GeometricSearchDet * >	theOuterComps

ReferenceCountingPointer< BoundCylinder >	theOuterCylinder

Protected Attributes inherited from GeometricSearchDet
bool	haveGroups

GeomDetCompatibilityChecker	theCompatibilityChecker

Detailed Description

A concrete implementation for TIB layer built out of TIBRings

Definition at line 13 of file TIBLayer.h.

Constructor & Destructor Documentation

◆ TIBLayer()

TIBLayer::TIBLayer	(	std::vector< const TIBRing *> &	innerRings,
		std::vector< const TIBRing *> &	outerRings
	)

Definition at line 18 of file TIBLayer.cc.

References cylinder(), mps_fire::i, BarrelDetLayer::initialize(), isDetLessZ(), LogDebug, jetUpdater_cfi::sort, BarrelDetLayer::specificSurface(), TBLayer::theBasicComps, TBLayer::theComps, theInnerBinFinder, TBLayer::theInnerComps, TBLayer::theInnerCylinder, theOuterBinFinder, TBLayer::theOuterComps, and TBLayer::theOuterCylinder.

     : TBLayer(innerRings, outerRings, GeomDetEnumerators::TIB) {
   theComps.assign(theInnerComps.begin(), theInnerComps.end());
   theComps.insert(theComps.end(), theOuterComps.begin(), theOuterComps.end());
 
   std::sort(theComps.begin(), theComps.end(), isDetLessZ);
   std::sort(theInnerComps.begin(), theInnerComps.end(), isDetLessZ);
   std::sort(theOuterComps.begin(), theOuterComps.end(), isDetLessZ);
 
   for (auto& it : theComps) {
     theBasicComps.insert(theBasicComps.end(), it->basicComponents().begin(), it->basicComponents().end());
   }
 
   // initialize the surface
   theInnerCylinder = cylinder(theInnerComps);
   theOuterCylinder = cylinder(theOuterComps);
   initialize();
 
   LogDebug("TkDetLayers") << "==== DEBUG TIBLayer =====";
   LogDebug("TkDetLayers") << "innerCyl radius, thickness, lenght: " << theInnerCylinder->radius() << " , "
                           << theInnerCylinder->bounds().thickness() << " , " << theInnerCylinder->bounds().length();
 
   LogDebug("TkDetLayers") << "outerCyl radius, thickness, lenght: " << theOuterCylinder->radius() << " , "
                           << theOuterCylinder->bounds().thickness() << " , " << theOuterCylinder->bounds().length();
 
   LogDebug("TkDetLayers") << "Cyl radius, thickness, lenght: " << specificSurface().radius() << " , "
                           << specificSurface().bounds().thickness() << " , " << specificSurface().bounds().length();
 
   for (auto& i : theInnerComps) {
     LogDebug("TkDetLayers") << "inner TIBRing pos z,radius,eta,phi: " << i->position().z() << " , "
                             << i->position().perp() << " , " << i->position().eta() << " , " << i->position().phi();
   }
 
   for (auto& i : theOuterComps) {
     LogDebug("TkDetLayers") << "outer TIBRing pos z,radius,eta,phi: " << i->position().z() << " , "
                             << i->position().perp() << " , " << i->position().eta() << " , " << i->position().phi();
   }
 
   // initialise the bin finders
   //  vector<const GeometricSearchDet*> tmpIn;
   //for (vector<const TIBRing*>::const_iterator i=theInnerRings.begin();
   //     i != theInnerRings.end(); i++) tmpIn.push_back(*i);
   theInnerBinFinder = GeneralBinFinderInZforGeometricSearchDet<float>(theInnerComps.begin(), theInnerComps.end());
 
   theOuterBinFinder = GeneralBinFinderInZforGeometricSearchDet<float>(theOuterComps.begin(), theOuterComps.end());
 }

◆ ~TIBLayer()

TIBLayer::~TIBLayer ( )

override

Definition at line 65 of file TIBLayer.cc.

65 {}

Member Function Documentation

◆ computeIndexes()

std::tuple< bool, int, int > TIBLayer::computeIndexes	(	GlobalPoint	gInnerPoint,
		GlobalPoint	gOuterPoint
	)		const

overrideprivatevirtual

Implements TBLayer.

Definition at line 92 of file TIBLayer.cc.

References funct::abs(), GeneralBinFinderInZforGeometricSearchDet< T >::binIndex(), GloballyPositioned< T >::position(), GeometricSearchDet::surface(), theInnerBinFinder, TBLayer::theInnerComps, theOuterBinFinder, TBLayer::theOuterComps, and PV3DBase< T, PVType, FrameType >::z().

                                                                                                         {
   int innerIndex = theInnerBinFinder.binIndex(gInnerPoint.z());
   const GeometricSearchDet* innerRing = theInnerComps[innerIndex];
   float innerDist = std::abs(innerRing->surface().position().z() - gInnerPoint.z());
 
   int outerIndex = theOuterBinFinder.binIndex(gOuterPoint.z());
   const GeometricSearchDet* outerRing = theOuterComps[outerIndex];
   float outerDist = std::abs(outerRing->surface().position().z() - gOuterPoint.z());
 
   return std::make_tuple(innerDist < outerDist, innerIndex, outerIndex);
 }

◆ computeWindowSize()

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

overrideprivatevirtual

Implements TBLayer.

Definition at line 152 of file TIBLayer.cc.

References funct::abs(), Surface::bounds(), TrajectoryStateOnSurface::globalMomentum(), MeasurementEstimator::maximalLocalDisplacement(), GeomDet::surface(), Bounds::thickness(), PV2DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                          {
   // we assume the outer and inner rings have about same thickness...
 
   //   edm::LogInfo(TkDetLayers) << "TIBLayer::computeWindowSize: Y axis of tangent plane is"
   //        << plane.toGlobal( LocalVector(0,1,0)) ;
 
   MeasurementEstimator::Local2DVector localError(est.maximalLocalDisplacement(tsos, det->surface()));
   float yError = localError.y();
 
   // float tanTheta = std::tan( tsos.globalMomentum().theta());
   auto gm = tsos.globalMomentum();
   auto cotanTheta = gm.z() / gm.perp();
   float thickCorrection = 0.5f * det->surface().bounds().thickness() * std::abs(cotanTheta);
 
   // FIXME: correct this in case of wide phi window !
 
   return yError + thickCorrection;
 }

◆ cylinder()

BoundCylinder * TIBLayer::cylinder ( const std::vector< const GeometricSearchDet *> & rings )

private

Definition at line 67 of file TIBLayer.cc.

References Bounds::length(), alignCSCRings::r, Bounds::thickness(), SiStripMonitorCluster_cfi::zmax, and SiStripMonitorCluster_cfi::zmin.

Referenced by TIBLayer().

                                                                                    {
   float leftPos = rings.front()->surface().position().z();
   float rightPos = rings.back()->surface().position().z();
 
   const BoundCylinder& frontRing = static_cast<const BoundCylinder&>(rings.front()->surface());
   const BoundCylinder& backRing = static_cast<const BoundCylinder&>(rings.back()->surface());
   float r = frontRing.radius();
   const Bounds& leftBounds = frontRing.bounds();
   const Bounds& rightBounds = backRing.bounds();
 
   //float r = rings.front()->specificSurface().radius();
   //const Bounds& leftBounds = rings.front()->specificSurface().bounds();
   //const Bounds& rightBounds = rings.back()->specificSurface().bounds();
 
   float thick = leftBounds.thickness() / 2;
   float zmin = leftPos - leftBounds.length() / 2;
   float zmax = rightPos + rightBounds.length() / 2;
   float rmin = r - thick;
   float rmax = r + thick;
   float zpos = 0.5 * (leftPos + rightPos);
 
   auto scp = new SimpleCylinderBounds(rmin, rmax, zmin - zpos, zmax - zpos);
   return new Cylinder(r, Surface::PositionType(0, 0, zpos), rings.front()->surface().rotation(), scp);
 }

◆ overlap()

bool TIBLayer::overlap	(	const GlobalPoint &	gpos,
		const GeometricSearchDet &	ring,
		float	window
	)

staticprivate

Definition at line 144 of file TIBLayer.cc.

References funct::abs(), Surface::bounds(), Bounds::length(), GeometricSearchDet::position(), GeometricSearchDet::surface(), svgfig::window(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by searchNeighbors().

                                                                                                  {
   float halfLength = 0.5f * det.surface().bounds().length();
 
   //   edm::LogInfo(TkDetLayers) << " TIBLayer: checking ring with z " << det.position().z();
 
   return std::abs(crossPoint.z() - det.position().z()) < (halfLength + window);
 }

◆ searchNeighbors()

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

overrideprivatevirtual

Implements TBLayer.

Definition at line 104 of file TIBLayer.cc.

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

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