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

override

Definition at line 65 of file TIBLayer.cc.

65 {}

Member Function Documentation

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

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;
 }

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

private

Definition at line 67 of file TIBLayer.cc.

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

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

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(), 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);
 }

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(), TBLayer::subLayer(), SubLayerCrossing::subLayerIndex(), 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;
   }
 }

Member Data Documentation

GeneralBinFinderInZforGeometricSearchDet<float> TIBLayer::theInnerBinFinder

private

Definition at line 39 of file TIBLayer.h.

Referenced by computeIndexes(), and TIBLayer().

GeneralBinFinderInZforGeometricSearchDet<float> TIBLayer::theOuterBinFinder

private

Definition at line 40 of file TIBLayer.h.

Referenced by computeIndexes(), and TIBLayer().

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation