#include <TIDLayer.h>

Inheritance diagram for TIDLayer:

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

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

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

virtual SubDetector	subDetector () const
	The type of detector (PixelBarrel, PixelEndcap, TIB, TOB, TID, TEC, CSC, DT, RPCBarrel, RPCEndcap) More...

	TIDLayer (std::vector< const TIDRing * > &rings)

	~TIDLayer ()

Public Member Functions inherited from RingedForwardLayer
	RingedForwardLayer ()

virtual	~RingedForwardLayer ()

Public Member Functions inherited from ForwardDetLayer
virtual std::pair< bool, TrajectoryStateOnSurface >	compatible (const TrajectoryStateOnSurface &, const Propagator &, const MeasurementEstimator &) const

bool	contains (const Local3DPoint &p) const

	ForwardDetLayer ()

virtual Location	location () const
	Which part of the detector (barrel, endcap) More...

virtual const BoundDisk &	specificSurface () const

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

virtual	~ForwardDetLayer ()

Public Member Functions inherited from DetLayer
std::vector< const DetLayer * >	compatibleLayers (NavigationDirection direction) const

std::vector< const DetLayer * >	compatibleLayers (const FreeTrajectoryState &fts, PropagationDirection timeDirection) const

std::vector< const DetLayer * >	compatibleLayers (const FreeTrajectoryState &fts, PropagationDirection timeDirection, int &counter) const

	DetLayer ()

NavigableLayer *	navigableLayer () const
	Return the NavigableLayer associated with this DetLayer. More...

virtual std::vector< const DetLayer * >	nextLayers (NavigationDirection direction) const

virtual std::vector< const DetLayer * >	nextLayers (const FreeTrajectoryState &fts, PropagationDirection timeDirection) const

virtual void	setNavigableLayer (NavigableLayer *nlp)
	Set the NavigableLayer associated with this DetLayer. More...

virtual	~DetLayer ()

Public Member Functions inherited from GeometricSearchDet
virtual std::vector< DetWithState >	compatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const

	GeometricSearchDet ()

virtual std::vector< DetGroup >	groupedCompatibleDets (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est) const

virtual const Surface::PositionType &	position () const
	Returns position of the surface. More...

virtual	~GeometricSearchDet ()

Public Member Functions inherited from GeometricSearchDetWithGroups
void	compatibleDetsV (const TrajectoryStateOnSurface &startingState, const Propagator &prop, const MeasurementEstimator &est, std::vector< DetWithState > &result) const

bool	hasGroups () const

Protected Member Functions
float	computeWindowSize (const GeomDet *det, const TrajectoryStateOnSurface &tsos, const MeasurementEstimator &est) const

int	findClosest (const GlobalPoint[3]) const

int	findNextIndex (const GlobalPoint[3], int) const

bool	overlapInR (const TrajectoryStateOnSurface &tsos, int i, double ymax) const

Protected Member Functions inherited from ForwardDetLayer
virtual BoundDisk *	computeSurface ()

virtual void	initialize ()

float	rmax () const

float	rmin () const

void	setSurface (BoundDisk *cp)

float	zmax () const

float	zmin () const

Static Protected Member Functions
static void	orderAndMergeLevels (const TrajectoryStateOnSurface &tsos, const Propagator &prop, const std::vector< std::vector< DetGroup > > &groups, const std::vector< int > &indices, std::vector< DetGroup > &result)

Protected Attributes
std::vector< const GeomDet * >	theBasicComps

std::vector< const GeometricSearchDet * >	theComps

Protected Attributes inherited from GeometricSearchDet
GeomDetCompatibilityChecker	theCompatibilityChecker

Private Member Functions
virtual BoundDisk *	computeDisk (const std::vector< const TIDRing * > &rings) const

virtual std::vector< int >	ringIndicesByCrossingProximity (const TrajectoryStateOnSurface &startingState, const Propagator &prop) const

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

Public Types inherited from GeometricSearchDetWithGroups
typedef GeometricSearchDet::DetWithState	DetWithState

Detailed Description

A concrete implementation for TID layer built out of TIDRings

Definition at line 14 of file TIDLayer.h.

Constructor & Destructor Documentation

TIDLayer::TIDLayer ( std::vector< const TIDRing * > & rings )

Definition at line 34 of file TIDLayer.cc.

References BoundSurface::bounds(), computeDisk(), BoundDisk::innerRadius(), LogDebug, BoundDisk::outerRadius(), PV3DBase< T, PVType, FrameType >::perp(), GeometricSearchDet::position(), ForwardDetLayer::setSurface(), ForwardDetLayer::specificSurface(), theBasicComps, theComps, Bounds::thickness(), and PV3DBase< T, PVType, FrameType >::z().

                                                :
   theComps(rings.begin(),rings.end())
 {
   //They should be already R-ordered. TO BE CHECKED!!
   //sort( theRings.begin(), theRings.end(), DetLessR());
   setSurface( computeDisk( rings ) );
 
   if ( theComps.size() != 3) throw DetLayerException("Number of rings in TID layer is not equal to 3 !!");
 
   for(vector<const GeometricSearchDet*>::const_iterator it=theComps.begin();
       it!=theComps.end();it++){  
     theBasicComps.insert(theBasicComps.end(),   
              (**it).basicComponents().begin(),
              (**it).basicComponents().end());
   }
 
  
   LogDebug("TkDetLayers") << "==== DEBUG TIDLayer =====" ; 
   LogDebug("TkDetLayers") << "r,zed pos  , thickness, innerR, outerR: " 
               << this->position().perp() << " , "
               << this->position().z() << " , "
               << this->specificSurface().bounds().thickness() << " , "
               << this->specificSurface().innerRadius() << " , "
               << this->specificSurface().outerRadius() ;
 }

TIDLayer::~TIDLayer ( )

Definition at line 92 of file TIDLayer.cc.

References i, and theComps.

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

Member Function Documentation

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

inlinevirtual

Implements GeometricSearchDet.

Definition at line 21 of file TIDLayer.h.

References theBasicComps.

21 {return theBasicComps;}

TIDLayer::theBasicComps

std::vector< const GeomDet * > theBasicComps

Definition: TIDLayer.h:66

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

inlinevirtual

Returns basic components, if any.

Returns direct components, if any

Implements GeometricSearchDet.

Definition at line 23 of file TIDLayer.h.

References theComps.

23 {return theComps;}

TIDLayer::theComps

std::vector< const GeometricSearchDet * > theComps

Definition: TIDLayer.h:65

BoundDisk * TIDLayer::computeDisk ( const std::vector< const TIDRing * > & rings ) const

privatevirtual

Definition at line 62 of file TIDLayer.cc.

References i, BoundDisk::innerRadius(), max(), min, pos, ForwardDetLayer::rmax(), ForwardDetLayer::rmin(), makeMuonMisalignmentScenario::rot, ForwardDetLayer::zmax(), ForwardDetLayer::zmin(), and zPos.

Referenced by TIDLayer().

 {
   float theRmin = rings.front()->specificSurface().innerRadius();
   float theRmax = rings.front()->specificSurface().outerRadius();
   float theZmin = rings.front()->position().z() -
     rings.front()->surface().bounds().thickness()/2;
   float theZmax = rings.front()->position().z() +
     rings.front()->surface().bounds().thickness()/2;
   
   for (vector<const TIDRing*>::const_iterator i = rings.begin(); i != rings.end(); i++) {
     float rmin = (**i).specificSurface().innerRadius();
     float rmax = (**i).specificSurface().outerRadius();
     float zmin = (**i).position().z() - (**i).surface().bounds().thickness()/2.;
     float zmax = (**i).position().z() + (**i).surface().bounds().thickness()/2.;
     theRmin = min( theRmin, rmin);
     theRmax = max( theRmax, rmax);
     theZmin = min( theZmin, zmin);
     theZmax = max( theZmax, zmax);
   }
   
   float zPos = (theZmax+theZmin)/2.;
   PositionType pos(0.,0.,zPos);
   RotationType rot;
 
   return new BoundDisk( pos, rot,SimpleDiskBounds(theRmin, theRmax,    
                  theZmin-zPos, theZmax-zPos));
 
 }

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

protected

Definition at line 218 of file TIDLayer.cc.

References MeasurementEstimator::maximalLocalDisplacement(), GeomDet::surface(), and PV2DBase< T, PVType, FrameType >::y().

Referenced by groupedCompatibleDetsV().

 {
   const BoundPlane& startPlane = det->surface();  
   MeasurementEstimator::Local2DVector maxDistance = 
     est.maximalLocalDisplacement( tsos, startPlane);
   return maxDistance.y();
 }

int TIDLayer::findClosest ( const GlobalPoint ringCrossing[3] ) const

protected

Definition at line 293 of file TIDLayer.cc.

References i, BoundDisk::innerRadius(), BoundDisk::outerRadius(), perp(), and theComps.

Referenced by ringIndicesByCrossingProximity().

 {
   int theBin = 0;
   const BoundDisk & theFrontRing  = static_cast<const BoundDisk &>(theComps[0]->surface());
   float initialR = 0.5*( theFrontRing.innerRadius() +
              theFrontRing.outerRadius());
   float rDiff = fabs( ringCrossing[0].perp() - initialR);
   for (int i = 1; i < 3 ; i++){
     const BoundDisk & theRing  = static_cast<const BoundDisk &>(theComps[i]->surface());
     float ringR = 0.5*( theRing.innerRadius() + 
             theRing.outerRadius());
     float testDiff = fabs( ringCrossing[i].perp() - ringR);
     if ( testDiff<rDiff ) {
       rDiff = testDiff;
       theBin = i;
     }
   }
   return theBin;
 }

int TIDLayer::findNextIndex	(	const GlobalPoint	ringCrossing[3],
		int	closest
	)		const

protected

Definition at line 314 of file TIDLayer.cc.

References i, BoundDisk::innerRadius(), BoundDisk::outerRadius(), perp(), and theComps.

Referenced by ringIndicesByCrossingProximity().

 {
 
   int firstIndexToCheck = (closest != 0)? 0 : 1; 
   const BoundDisk & theFrontRing  = static_cast<const BoundDisk &>(theComps[firstIndexToCheck]->surface());
   float initialR = ( theFrontRing.innerRadius() +
              theFrontRing.outerRadius())/2.;         
 
   float rDiff = fabs( ringCrossing[0].perp() - initialR);
   int theBin = firstIndexToCheck;
   for (int i = firstIndexToCheck+1; i < 3 ; i++){
     if ( i != closest) {
       const BoundDisk & theRing  = static_cast<const BoundDisk &>(theComps[i]->surface());
       float ringR = ( theRing.innerRadius() + 
               theRing.outerRadius())/2.;
       float testDiff = fabs( ringCrossing[i].perp() - ringR);
       if ( testDiff<rDiff ) {
     rDiff = testDiff;
     theBin = i;
       }
     }
   }
   return theBin;
 }

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

virtual

Reimplemented from GeometricSearchDet.

Definition at line 103 of file TIDLayer.cc.

References computeWindowSize(), orderAndMergeLevels(), overlapInR(), query::result, ringIndicesByCrossingProximity(), and theComps.

 {
   vector<int> ringIndices = ringIndicesByCrossingProximity(startingState,prop);
   if ( ringIndices.size()!=3 ) {
     edm::LogError("TkDetLayers") << "TkRingedForwardLayer::groupedCompatibleDets : ringIndices.size() = "
                  << ringIndices.size() << " and not =3!!" ;
     return;
   }
 
   vector<DetGroup> closestResult;
   vector<DetGroup> nextResult;
   vector<DetGroup> nextNextResult;
   vector<vector<DetGroup> > groupsAtRingLevel;
 
   theComps[ringIndices[0]]->groupedCompatibleDetsV( startingState, prop, est, closestResult);       
   if ( closestResult.empty() ){
     theComps[ringIndices[1]]->groupedCompatibleDetsV( startingState, prop, est, result); 
     return;
   }
 
   groupsAtRingLevel.push_back(closestResult);
 
   DetGroupElement closestGel( closestResult.front().front());  
   float rWindow = computeWindowSize( closestGel.det(), closestGel.trajectoryState(), est); 
   if(!overlapInR(closestGel.trajectoryState(),ringIndices[1],rWindow)) {
     result.swap(closestResult);
     return;
   };
 
   nextResult.clear();
   theComps[ringIndices[1]]->groupedCompatibleDetsV( startingState, prop, est, nextResult);
   if(nextResult.empty()) {
     result.swap(closestResult);
     return;
   }
   groupsAtRingLevel.push_back(nextResult);
 
   if(!overlapInR(closestGel.trajectoryState(),ringIndices[2],rWindow) ) {
     //then merge 2 levels & return 
     orderAndMergeLevels(closestGel.trajectoryState(),prop,groupsAtRingLevel,ringIndices,result);      
     return;
   }
 
   theComps[ringIndices[2]]->groupedCompatibleDetsV( startingState, prop, est, nextNextResult);   
   if(nextNextResult.empty()) {
     // then merge 2 levels and return 
     orderAndMergeLevels(closestGel.trajectoryState(),prop,groupsAtRingLevel,ringIndices,result);
     return;
   }
 
   groupsAtRingLevel.push_back(nextNextResult);
   // merge 3 level and return merged   
   orderAndMergeLevels(closestGel.trajectoryState(),prop,groupsAtRingLevel,ringIndices, result);  
 }

void TIDLayer::orderAndMergeLevels	(	const TrajectoryStateOnSurface &	tsos,
		const Propagator &	prop,
		const std::vector< std::vector< DetGroup > > &	groups,
		const std::vector< int > &	indices,
		std::vector< DetGroup > &	result
	)

staticprotected

Definition at line 261 of file TIDLayer.cc.

References alongMomentum, TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), i, oppositeToMomentum, Propagator::propagationDirection(), python.multivaluedict::sort(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by groupedCompatibleDetsV().

 {
   vector< pair<vector<DetGroup> const *,int> > groupPlusIndex;
 
   for(unsigned int i=0;i<groups.size();i++){
     groupPlusIndex.push_back(pair<vector<DetGroup> const *,int>(&groups[i],indices[i]) );
   }
   //order is ring3,ring1,ring2
   std::sort(groupPlusIndex.begin(),groupPlusIndex.end(),TIDringLess());
   
 
   float zpos = tsos.globalPosition().z();
   if(tsos.globalMomentum().z()*zpos>0){ // momentum points outwards
     if(prop.propagationDirection() == alongMomentum)
       mergeOutward(groupPlusIndex,result);
     else
       mergeInward(groupPlusIndex,result);
   }
   else{ //  momentum points inwards
     if(prop.propagationDirection() == oppositeToMomentum)
       mergeOutward(groupPlusIndex,result);
     else
       mergeInward(groupPlusIndex,result);    
   }  
   
 }

bool TIDLayer::overlapInR	(	const TrajectoryStateOnSurface &	tsos,
		int	i,
		double	ymax
	)		const

protected

Definition at line 342 of file TIDLayer.cc.

References BoundSurface::bounds(), TrajectoryStateOnSurface::globalPosition(), getHLTprescales::index, BoundDisk::innerRadius(), max(), BoundDisk::outerRadius(), PV3DBase< T, PVType, FrameType >::perp(), GloballyPositioned< T >::position(), theComps, Bounds::thickness(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by groupedCompatibleDetsV().

 {
   // assume "fixed theta window", i.e. margin in local y = r is changing linearly with z
   float tsRadius = tsos.globalPosition().perp();
   float thetamin = ( max(0.,tsRadius-ymax))/(fabs(tsos.globalPosition().z())+10.); // add 10 cm contingency 
   float thetamax = ( tsRadius + ymax)/(fabs(tsos.globalPosition().z())-10.);
   
   const BoundDisk& ringDisk = static_cast<const BoundDisk&>(theComps[index]->surface());
   float ringMinZ = fabs( ringDisk.position().z()) - ringDisk.bounds().thickness()/2.;
   float ringMaxZ = fabs( ringDisk.position().z()) + ringDisk.bounds().thickness()/2.; 
   float thetaRingMin =  ringDisk.innerRadius()/ ringMaxZ;
   float thetaRingMax =  ringDisk.outerRadius()/ ringMinZ;
 
   // do the theta regions overlap ?
 
   return !( thetamin > thetaRingMax || thetaRingMin > thetamax);
 }

vector< int > TIDLayer::ringIndicesByCrossingProximity	(	const TrajectoryStateOnSurface &	startingState,
		const Propagator &	prop
	)		const

privatevirtual

Definition at line 163 of file TIDLayer.cc.

References findClosest(), findNextIndex(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), i, errorMatrix2Lands::indices, Propagator::propagationDirection(), rho, theComps, and TrajectoryStateOnSurface::transverseCurvature().

Referenced by groupedCompatibleDetsV().

 {
   typedef HelixForwardPlaneCrossing Crossing; 
   typedef MeasurementEstimator::Local2DVector Local2DVector;
 
   HelixPlaneCrossing::PositionType startPos( startingState.globalPosition());
   HelixPlaneCrossing::DirectionType startDir( startingState.globalMomentum());
   PropagationDirection propDir( prop.propagationDirection());
   float rho( startingState.transverseCurvature());
 
   // calculate the crossings with the ring surfaces
   // rings are assumed to be sorted in R !
   
   Crossing myXing(  startPos, startDir, rho, propDir );
 
   GlobalPoint   ringCrossings[3];
   // vector<GlobalVector>  ringXDirections;
 
   for (int i = 0; i < 3 ; i++ ) {
     const BoundDisk & theRing  = static_cast<const BoundDisk &>(theComps[i]->surface());
     pair<bool,double> pathlen = myXing.pathLength( theRing);
     if ( pathlen.first ) { 
       ringCrossings[i] = GlobalPoint( myXing.position(pathlen.second ));
       // ringXDirections.push_back( GlobalVector( myXing.direction(pathlen.second )));
     } else {
       // TO FIX.... perhaps there is something smarter to do
       //throw DetLayerException("trajectory doesn't cross TID rings");
       ringCrossings[i] = GlobalPoint( 0.,0.,0.);
       //  ringXDirections.push_back( GlobalVector( 0.,0.,0.));
     }
   }
 
   int closestIndex = findClosest(ringCrossings);
   int nextIndex    = findNextIndex(ringCrossings,closestIndex);
   if ( closestIndex<0 || nextIndex<0 )  return vector<int>();
   int nextNextIndex = -1;
   for(int i=0; i<3 ; i++){
     if(i!= closestIndex && i!=nextIndex) {
       nextNextIndex = i;
       break;
     }
   }
   
   vector<int> indices;
   indices.push_back(closestIndex);
   indices.push_back(nextIndex);
   indices.push_back(nextNextIndex);
   return indices;
 }