#include <TIBLayer.h>

Inheritance diagram for TIBLayer:

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

	~TIBLayer () __attribute__((cold))

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

virtual 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 final __attribute__((hot))

virtual 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 () __attribute__((cold))

Public Member Functions inherited from BarrelDetLayer
	BarrelDetLayer (bool doHaveGroup)

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

bool	contains (const Local3DPoint &p) const

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

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

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

virtual	~BarrelDetLayer ()

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

bool	isBarrel () const

bool	isForward () const

int	seqNum () const

void	setSeqNum (int sq)

virtual	~DetLayer ()

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

float	computeWindowSize (const GeomDet *det, const TrajectoryStateOnSurface &tsos, const MeasurementEstimator &est) const __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 __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 20 of file TIBLayer.cc.

References cylinder(), i, BarrelDetLayer::initialize(), LogDebug, python.multivaluedict::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());
   
   sort(theComps.begin(),theComps.end(),DetLessZ());
   sort(theInnerComps.begin(),theInnerComps.end(),DetLessZ());
   sort(theOuterComps.begin(),theOuterComps.end(),DetLessZ());
   
   for(vector<const GeometricSearchDet*>::const_iterator it=theComps.begin();
       it!=theComps.end();it++){  
     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 (vector<const GeometricSearchDet*>::const_iterator i=theInnerComps.begin();
        i != theInnerComps.end(); i++){
     LogDebug("TkDetLayers") << "inner TIBRing pos z,radius,eta,phi: " 
                 << (**i).position().z() << " , " 
                 << (**i).position().perp() << " , " 
                 << (**i).position().eta() << " , " 
                 << (**i).position().phi() ;
   }
 
   for (vector<const GeometricSearchDet*>::const_iterator i=theOuterComps.begin();
        i != theOuterComps.end(); i++){
     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 ( )

Definition at line 89 of file TIBLayer.cc.

89 {}

Member Function Documentation

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

privatevirtual

Implements TBLayer.

Definition at line 124 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

privatevirtual

Implements TBLayer.

Definition at line 189 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 95 of file TIBLayer.cc.

References Bounds::length(), alignCSCRings::r, Bounds::thickness(), SiStripMonitorClusterAlca_cfi::zmax, and SiStripMonitorClusterAlca_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);
 
 }

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

staticprivate

Definition at line 178 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

privatevirtual

Implements TBLayer.

Definition at line 140 of file TIBLayer.cc.

References Clusterizer1DCommons::add(), SubLayerCrossing::closestDetIndex(), overlap(), SubLayerCrossing::position(), TBLayer::subLayer(), SubLayerCrossing::subLayerIndex(), and PV3DBase< T, PVType, FrameType >::z().

 {
   GlobalPoint gCrossingPos = crossing.position();
 
   const 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 42 of file TIBLayer.h.

Referenced by computeIndexes(), and TIBLayer().

GeneralBinFinderInZforGeometricSearchDet<float> TIBLayer::theOuterBinFinder

private

Definition at line 43 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