CMSSW Reference Manual

typedef ctfseeding::SeedingLayer HitPairGeneratorFromLayerPair::Layer

Definition at line 17 of file HitPairGeneratorFromLayerPair.h.

typedef CombinedHitPairGenerator::LayerCacheType HitPairGeneratorFromLayerPair::LayerCacheType

Definition at line 16 of file HitPairGeneratorFromLayerPair.h.

HitPairGeneratorFromLayerPair::HitPairGeneratorFromLayerPair	(	const Layer &	inner,
		const Layer &	outer,
		LayerCacheType *	layerCache,
		unsigned int	nSize = `30000`
	)

Definition at line 36 of file HitPairGeneratorFromLayerPair.cc.

Referenced by clone().

00038   : HitPairGenerator(nSize),
00039     theLayerCache(*layerCache), theOuterLayer(outer), theInnerLayer(inner)
00040 { }

virtual HitPairGeneratorFromLayerPair::~HitPairGeneratorFromLayerPair ( ) [inline, virtual]

Definition at line 21 of file HitPairGeneratorFromLayerPair.h.

00021 { }

virtual HitPairGeneratorFromLayerPair* HitPairGeneratorFromLayerPair::clone ( void ) const [inline, virtual]

Implements HitPairGenerator.

Definition at line 26 of file HitPairGeneratorFromLayerPair.h.

References HitPairGeneratorFromLayerPair().

00026                                                        {
00027     return new HitPairGeneratorFromLayerPair(*this);
00028   }

void HitPairGeneratorFromLayerPair::hitPairs	(	const TrackingRegion &	reg,
		OrderedHitPairs &	prs,
		const edm::Event &	ev,
		const edm::EventSetup &	es
	)			`[virtual]`

Implements HitPairGenerator.

Definition at line 42 of file HitPairGeneratorFromLayerPair.cc.

References GeomDetEnumerators::barrel, BoundSurface::bounds(), TrackingRegion::checkRZ(), funct::cos(), deltaPhi(), ctfseeding::SeedingLayer::detLayer(), PixelRecoRange< T >::empty(), LayerHitMap::empty(), LayerHitMapLoop::getHit(), TrackingRegionBase::hitErrRPhi(), hitPairsWithErrors(), DetLayer::location(), LayerHitMap::loop(), TrackingRegion::origin(), ctfseeding::SeedingHit::phi(), GeomDetEnumerators::PixelBarrel, GeometricSearchDet::position(), ctfseeding::SeedingHit::r(), Cylinder::radius(), radius(), funct::sin(), BarrelDetLayer::specificSurface(), sqr(), funct::sqrt(), DetLayer::subDetector(), GeometricSearchDet::surface(), BarrelDetLayer::surface(), theInnerLayer, theLayerCache, theOuterLayer, Bounds::thickness(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), ctfseeding::SeedingHit::z(), and PV3DBase< T, PVType, FrameType >::z().

00045 {
00046 
00047   if (theInnerLayer.detLayer()->subDetector() != PixelBarrel &&
00048       theInnerLayer.detLayer()->location() == barrel ){
00049     hitPairsWithErrors(region,result,iEvent,iSetup);
00050     return;
00051   }
00052 
00053   typedef OrderedHitPair::InnerHit InnerHit;
00054   typedef OrderedHitPair::OuterHit OuterHit;
00055 
00056   const LayerHitMap & innerHitsMap = theLayerCache(&theInnerLayer, region, iEvent, iSetup);
00057   if (innerHitsMap.empty()) return;
00058  
00059   const LayerHitMap & outerHitsMap = theLayerCache(&theOuterLayer, region, iEvent, iSetup);
00060   if (outerHitsMap.empty()) return;
00061 
00062   const DetLayer * innerlay = theInnerLayer.detLayer();
00063   const DetLayer * outerlay = theOuterLayer.detLayer();
00064   
00065   float outerHitErrorRPhi = (outerlay->location() == barrel) ?
00066       TrackingRegionBase::hitErrRPhi(
00067           dynamic_cast<const BarrelDetLayer*>(outerlay) )
00068     : TrackingRegionBase::hitErrRPhi(
00069           dynamic_cast<const ForwardDetLayer*>(outerlay) ) ;
00070 
00071   InnerDeltaPhi deltaPhi(*innerlay, region, iSetup);
00072 
00073   float rzLayer1, rzLayer2;
00074   if (innerlay->location() == barrel) {
00075     const BarrelDetLayer& bl = 
00076         dynamic_cast<const BarrelDetLayer&>(*innerlay);
00077     float halfThickness  = bl.surface().bounds().thickness()/2;
00078     float radius = bl.specificSurface().radius();
00079     rzLayer1 = radius-halfThickness;
00080     rzLayer2 = radius+halfThickness;
00081   } 
00082   else {
00083     float halfThickness  = innerlay->surface().bounds().thickness()/2;
00084     float zLayer = innerlay->position().z() ;
00085     rzLayer1 = zLayer-halfThickness;
00086     rzLayer2 = zLayer+halfThickness;
00087   }
00088 
00089   const SeedingHit * oh;
00090   LayerHitMapLoop outerHits = outerHitsMap.loop();
00091 
00092   while ( (oh=outerHits.getHit()) ) {
00093     
00094     PixelRecoRange<float> phiRange = deltaPhi( oh->r(), oh->phi(), oh->z(), outerHitErrorRPhi);    
00095     if (phiRange.empty()) continue;
00096 
00097     const HitRZCompatibility *checkRZ = region.checkRZ(&(*innerlay), *oh, iSetup);
00098     if(!checkRZ) continue;
00099 
00100     LayerHitMapLoop innerHits = innerHitsMap.loop(phiRange, Range(-100.,100.));
00101     const SeedingHit * ih;
00102     while ( (ih=innerHits.getHit()) ) {
00103       float ih_x = ih->r() * cos(ih->phi());
00104       float ih_y = ih->r() * sin(ih->phi());
00105       float r_reduced = sqrt( sqr(ih_x-region.origin().x())+sqr(ih_y-region.origin().y()));
00106 
00107       if ( (*checkRZ)( r_reduced, ih->z()) ) {
00108             result.push_back( OrderedHitPair( *ih, *oh) ); 
00109         }
00110     }
00111     delete checkRZ;
00112   }
00113 }

void HitPairGeneratorFromLayerPair::hitPairsWithErrors	(	const TrackingRegion &	ar,
		OrderedHitPairs &	ap,
		const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)			`[private]`

Definition at line 117 of file HitPairGeneratorFromLayerPair.cc.

References GeomDetEnumerators::barrel, TransientTrackingRecHitBuilder::build(), TrackingRegion::checkRZ(), deltaPhi(), ctfseeding::SeedingLayer::detLayer(), edm::EventSetup::get(), ctfseeding::SeedingLayer::hits(), TrackingRegion::hits(), RecHitsSortedInPhi::hits(), it, DetLayer::location(), PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), edm::ESHandle< T >::product(), HitRZCompatibility::range(), funct::sqrt(), theInnerLayer, theOuterLayer, and PV3DBase< T, PVType, FrameType >::z().

Referenced by hitPairs().

00121 {
00122   const TransientTrackingRecHitBuilder * TTRHbuilder = 0;
00123   const TrackerGeometry * trackerGeometry = 0;
00124   //if(TTRHbuilder == 0){
00125     edm::ESHandle<TransientTrackingRecHitBuilder> theBuilderHandle;
00126     iSetup.get<TransientRecHitRecord>().get("WithoutRefit",theBuilderHandle);
00127     TTRHbuilder = theBuilderHandle.product();
00128   //}
00129   //if (!trackerGeometry) {
00130     edm::ESHandle<TrackerGeometry> tracker;
00131     iSetup.get<TrackerDigiGeometryRecord>().get(tracker);
00132     trackerGeometry = tracker.product();
00133   //}
00134 
00135 
00136   typedef OrderedHitPair::InnerHit InnerHit;
00137   typedef OrderedHitPair::OuterHit OuterHit;
00138 
00139    vector<SeedingHit> oSHits(region.hits(iEvent,iSetup,&theOuterLayer));
00140    vector<const TrackingRecHit*> outerHits;
00141    typedef vector<SeedingHit>::const_iterator ISH;
00142    for (ISH it=oSHits.begin(); it != oSHits.end(); ++it) outerHits.push_back( *it);
00143    vector<SeedingHit> iSHits(theInnerLayer.hits(iEvent,iSetup));
00144    vector<const TrackingRecHit*> innerHits;
00145    for (ISH it=iSHits.begin(); it != iSHits.end(); ++it) innerHits.push_back( *it);
00146    RecHitsSortedInPhi innerSortedHits(innerHits,trackerGeometry);
00147    
00148                                    
00149   InnerDeltaPhi deltaPhi(
00150       *(theInnerLayer.detLayer()), region, iSetup);
00151 
00152   typedef vector<const TrackingRecHit*>::const_iterator  HI;
00153   float nSigmaRZ = sqrt(12.);
00154   float nSigmaPhi = 3.;
00155   for (HI oh=outerHits.begin(); oh!= outerHits.end(); oh++) {
00156     TransientTrackingRecHit::RecHitPointer recHit = TTRHbuilder->build(*oh);
00157     GlobalPoint hitPos = recHit->globalPosition();
00158     float phiErr = nSigmaPhi * sqrt(recHit->globalPositionError().phierr(hitPos)); 
00159     float dphi = deltaPhi( hitPos.perp(), hitPos.z(), hitPos.perp()*phiErr);   
00160     float phiHit = hitPos.phi();
00161     //std::cout<<"hit pairs generator dphi:"<<dphi<<std::endl;
00162     vector<const TrackingRecHit*> innerCandid = innerSortedHits.hits(phiHit-dphi,phiHit+dphi);
00163     const HitRZCompatibility *checkRZ = region.checkRZ(theInnerLayer.detLayer(), *oh,iSetup);
00164     if(!checkRZ) continue;
00165 
00166     for (HI ih = innerCandid.begin(); ih != innerCandid.end(); ih++) {
00167       TransientTrackingRecHit::RecHitPointer recHit = TTRHbuilder->build(&(**ih));
00168       GlobalPoint innPos = recHit->globalPosition();
00169       Range allowed = checkRZ->range(innPos.perp());
00170       Range hitRZ;
00171       if (theInnerLayer.detLayer()->location() == barrel) {
00172         float zErr = nSigmaRZ * sqrt(recHit->globalPositionError().czz());
00173         hitRZ = Range(innPos.z()-zErr, innPos.z()+zErr);
00174       } else {
00175         float rErr = nSigmaRZ * sqrt(recHit->globalPositionError().rerr(innPos));
00176         hitRZ = Range(innPos.perp()-rErr, innPos.perp()+rErr);
00177       }
00178       Range crossRange = allowed.intersection(hitRZ);
00179       if (! crossRange.empty() ) {
00180         result.push_back( OrderedHitPair( SeedingHit(*ih,theInnerLayer,iSetup), SeedingHit(*oh,theOuterLayer, iSetup) ) );
00181       }
00182     } 
00183     delete checkRZ;
00184   }
00185 }

const Layer& HitPairGeneratorFromLayerPair::innerLayer ( ) const [inline]

Definition at line 30 of file HitPairGeneratorFromLayerPair.h.

References theInnerLayer.

00030 { return theInnerLayer; }

const Layer& HitPairGeneratorFromLayerPair::outerLayer ( ) const [inline]

Definition at line 31 of file HitPairGeneratorFromLayerPair.h.

References theOuterLayer.

00031 { return theOuterLayer; }

Layer HitPairGeneratorFromLayerPair::theInnerLayer [private]

Definition at line 42 of file HitPairGeneratorFromLayerPair.h.

Referenced by hitPairs(), hitPairsWithErrors(), and innerLayer().

LayerCacheType& HitPairGeneratorFromLayerPair::theLayerCache [private]

Definition at line 40 of file HitPairGeneratorFromLayerPair.h.

Referenced by hitPairs().

Layer HitPairGeneratorFromLayerPair::theOuterLayer [private]

Definition at line 41 of file HitPairGeneratorFromLayerPair.h.

Referenced by hitPairs(), hitPairsWithErrors(), and outerLayer().


Public Types
typedef ctfseeding::SeedingLayer	Layer
typedef CombinedHitPairGenerator::LayerCacheType	LayerCacheType
Public Member Functions
virtual HitPairGeneratorFromLayerPair *	clone () const
	HitPairGeneratorFromLayerPair (const Layer &inner, const Layer &outer, LayerCacheType *layerCache, unsigned int nSize=30000)
virtual void	hitPairs (const TrackingRegion &reg, OrderedHitPairs &prs, const edm::Event &ev, const edm::EventSetup &es)
const Layer &	innerLayer () const
const Layer &	outerLayer () const
virtual	~HitPairGeneratorFromLayerPair ()
Private Member Functions
void	hitPairsWithErrors (const TrackingRegion &ar, OrderedHitPairs &ap, const edm::Event &iEvent, const edm::EventSetup &iSetup)
Private Attributes
Layer	theInnerLayer
LayerCacheType &	theLayerCache
Layer	theOuterLayer

HitPairGeneratorFromLayerPair Class Reference

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation