#include <PixelTripletHLTGenerator.h>

Inheritance diagram for PixelTripletHLTGenerator:

Public Member Functions
virtual void	hitTriplets (const TrackingRegion &region, OrderedHitTriplets &trs, const edm::Event &ev, const edm::EventSetup &es)

virtual void	init (const HitPairGenerator &pairs, const std::vector< ctfseeding::SeedingLayer > &layers, LayerCacheType *layerCache)

const HitPairGenerator &	pairGenerator () const

	PixelTripletHLTGenerator (const edm::ParameterSet &cfg)

const std::vector < ctfseeding::SeedingLayer > &	thirdLayers () const

virtual	~PixelTripletHLTGenerator ()

Public Member Functions inherited from HitTripletGeneratorFromPairAndLayers
virtual	~HitTripletGeneratorFromPairAndLayers ()

Public Member Functions inherited from HitTripletGenerator
virtual void	clear ()

	HitTripletGenerator (unsigned int size=500)

virtual void	hitTriplets (const TrackingRegion &reg, OrderedHitTriplets &prs, const edm::EventSetup &es)

virtual const OrderedHitTriplets &	run (const TrackingRegion &region, const edm::Event &ev, const edm::EventSetup &es)

virtual	~HitTripletGenerator ()

Public Member Functions inherited from OrderedHitsGenerator
	OrderedHitsGenerator ()

virtual	~OrderedHitsGenerator ()

Private Types
typedef CombinedHitTripletGenerator::LayerCacheType	LayerCacheType

Private Member Functions
bool	checkPhiInRange (float phi, float phi1, float phi2) const

std::pair< float, float >	mergePhiRanges (const std::pair< float, float > &r1, const std::pair< float, float > &r2) const

Private Attributes
float	dphi

float	extraHitRPhitolerance

float	extraHitRZtolerance

SeedComparitor *	theComparitor

LayerCacheType *	theLayerCache

std::vector < ctfseeding::SeedingLayer >	theLayers

HitPairGenerator *	thePairGenerator

bool	useBend

bool	useFixedPreFiltering

bool	useMScat

Additional Inherited Members
Public Types inherited from HitTripletGeneratorFromPairAndLayers
typedef LayerHitMapCache	LayerCacheType

Public Attributes inherited from OrderedHitsGenerator
unsigned int	theMaxElement

Detailed Description

Definition at line 23 of file PixelTripletHLTGenerator.h.

Member Typedef Documentation

typedef CombinedHitTripletGenerator::LayerCacheType PixelTripletHLTGenerator::LayerCacheType

private

Definition at line 25 of file PixelTripletHLTGenerator.h.

Constructor & Destructor Documentation

PixelTripletHLTGenerator::PixelTripletHLTGenerator ( const edm::ParameterSet & cfg )

Definition at line 26 of file PixelTripletHLTGenerator.cc.

References dphi, reco::get(), edm::ParameterSet::getParameter(), theComparitor, OrderedHitsGenerator::theMaxElement, and useFixedPreFiltering.

     : thePairGenerator(0),
       theLayerCache(0),
       useFixedPreFiltering(cfg.getParameter<bool>("useFixedPreFiltering")),
       extraHitRZtolerance(cfg.getParameter<double>("extraHitRZtolerance")),
       extraHitRPhitolerance(cfg.getParameter<double>("extraHitRPhitolerance")),
       useMScat(cfg.getParameter<bool>("useMultScattering")),
       useBend(cfg.getParameter<bool>("useBending"))
 {
   theMaxElement=cfg.getParameter<unsigned int>("maxElement");
   dphi =  (useFixedPreFiltering) ?  cfg.getParameter<double>("phiPreFiltering") : 0;
 
   edm::ParameterSet comparitorPSet =
     cfg.getParameter<edm::ParameterSet>("SeedComparitorPSet");
   std::string comparitorName = comparitorPSet.getParameter<std::string>("ComponentName");
   theComparitor = (comparitorName == "none") ? 
     0 :  SeedComparitorFactory::get()->create( comparitorName, comparitorPSet);   
 
 }

PixelTripletHLTGenerator::~PixelTripletHLTGenerator ( )

virtual

Definition at line 46 of file PixelTripletHLTGenerator.cc.

References theComparitor, and thePairGenerator.

 { delete thePairGenerator; 
   delete theComparitor; 
 }

Member Function Documentation

bool PixelTripletHLTGenerator::checkPhiInRange	(	float	phi,
		float	phi1,
		float	phi2
	)		const

private

Definition at line 221 of file PixelTripletHLTGenerator.cc.

References Geom::ftwoPi().

Referenced by hitTriplets().

 {
   while (phi > phi2) phi -=  Geom::ftwoPi();
   while (phi < phi1) phi +=  Geom::ftwoPi();
   return (  (phi1 <= phi) && (phi <= phi2) );
 }  

void PixelTripletHLTGenerator::hitTriplets	(	const TrackingRegion &	region,
		OrderedHitTriplets &	trs,
		const edm::Event &	ev,
		const edm::EventSetup &	es
	)

virtual

Implements HitTripletGenerator.

Definition at line 61 of file PixelTripletHLTGenerator.cc.

References GeomDetEnumerators::barrel, checkPhiInRange(), SeedComparitor::compatible(), PixelRecoUtilities::curvature(), dphi, extraHitRPhitolerance, extraHitRZtolerance, f, HitPairGenerator::hitPairs(), SeedComparitor::init(), ThirdHitRZPredictionBase::initLayer(), ThirdHitRZPrediction< Propagator >::initPropagator(), PixelRecoRange< T >::intersection(), geometryCSVtoXML::line, DetLayer::location(), LogDebug, max(), PixelRecoRange< T >::max(), mergePhiRanges(), min, nSigmaPhi, nSigmaRZ, TrackingRegion::origin(), TrackingRegion::originRBound(), PV3DBase< T, PVType, FrameType >::perp(), point, TrackingRegion::ptMin(), CosmicsPD_Skims::radius, OrderedHitTriplets::size(), findQualityFiles::size, mathSSE::sqrt(), PixelRecoRange< T >::sum(), theComparitor, theLayers, OrderedHitsGenerator::theMaxElement, thePairGenerator, useBend, useFixedPreFiltering, useMScat, Hit::x, PV3DBase< T, PVType, FrameType >::x(), Hit::y, PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

 {
   if (theComparitor) theComparitor->init(es);
   OrderedHitPairs pairs; pairs.reserve(30000);
   OrderedHitPairs::const_iterator ip;
   
   thePairGenerator->hitPairs(region,pairs,ev,es);
 
   if (pairs.empty()) return;
 
   int size = theLayers.size();
 
   typedef std::vector<ThirdHitRZPrediction<PixelRecoLineRZ> >  Preds;
   Preds preds(size);
 
   std::vector<const RecHitsSortedInPhi *> thirdHitMap(size);
   typedef RecHitsSortedInPhi::Hit Hit;
   vector<Hit> thirdHits;
 
   // fill the prediciton vetor
   for (int il=0; il!=size; ++il) {
      thirdHitMap[il] = &(*theLayerCache)(&theLayers[il], region, ev, es);
      ThirdHitRZPrediction<PixelRecoLineRZ> & pred = preds[il];
      pred.initLayer(theLayers[il].detLayer());
      pred.initTolerance(extraHitRZtolerance);
   }
 
 
   double imppar = region.originRBound();
   double curv = PixelRecoUtilities::curvature(1/region.ptMin(), es);
 
   for (ip = pairs.begin(); ip != pairs.end(); ip++) {
   
     GlobalPoint gp1tmp = (*ip).inner()->globalPosition();
     GlobalPoint gp2tmp = (*ip).outer()->globalPosition();
     GlobalPoint gp1(gp1tmp.x()-region.origin().x(), gp1tmp.y()-region.origin().y(), gp1tmp.z());
     GlobalPoint gp2(gp2tmp.x()-region.origin().x(), gp2tmp.y()-region.origin().y(), gp2tmp.z());
 
     PixelRecoPointRZ point1(gp1.perp(), gp1.z());
     PixelRecoPointRZ point2(gp2.perp(), gp2.z());
     PixelRecoLineRZ  line(point1, point2);
     ThirdHitPredictionFromInvParabola predictionRPhi(gp1,gp2,imppar,curv,extraHitRPhitolerance);
     ThirdHitPredictionFromInvParabola predictionRPhitmp(gp1tmp,gp2tmp,imppar+region.origin().perp(),curv,extraHitRPhitolerance);
 
 
     for (int il=0; il!=size; ++il) {
       const DetLayer * layer = theLayers[il].detLayer();
 //      bool pixelLayer = (    layer->subDetector() == GeomDetEnumerators::PixelBarrel 
 //                          || layer->subDetector() == GeomDetEnumerators::PixelEndcap); 
       bool barrelLayer = (layer->location() == GeomDetEnumerators::barrel);
 
       ThirdHitCorrection correction(es, region.ptMin(), layer, line, point2, useMScat, useBend); 
       
       ThirdHitRZPrediction<PixelRecoLineRZ> & predictionRZ =  preds[il];
 
       predictionRZ.initPropagator(&line);
       Range rzRange = predictionRZ();
 
       correction.correctRZRange(rzRange);
       Range phiRange;
       if (useFixedPreFiltering) { 
         float phi0 = (*ip).outer()->globalPosition().phi();
         phiRange = Range(phi0-dphi,phi0+dphi);
       }
       else {
         Range radius;
         if (barrelLayer) {
           radius =  predictionRZ.detRange();
         } else {
           radius = Range(
               max(rzRange.min(), predictionRZ.detSize().min()),
               min(rzRange.max(), predictionRZ.detSize().max()) );
         }
         if (radius.empty()) continue;
         Range rPhi1m = predictionRPhitmp(radius.max(), -1);
         Range rPhi1p = predictionRPhitmp(radius.max(),  1);
         Range rPhi2m = predictionRPhitmp(radius.min(), -1);
         Range rPhi2p = predictionRPhitmp(radius.min(),  1);
         Range rPhi1 = rPhi1m.sum(rPhi1p);
         Range rPhi2 = rPhi2m.sum(rPhi2p);
         correction.correctRPhiRange(rPhi1);
         correction.correctRPhiRange(rPhi2);
         rPhi1.first  /= radius.max();
         rPhi1.second /= radius.max();
         rPhi2.first  /= radius.min();
         rPhi2.second /= radius.min();
         phiRange = mergePhiRanges(rPhi1,rPhi2);
       }
       
 //      LayerHitMapLoop thirdHits = 
 //          pixelLayer ? thirdHitMap[il]->loop(phiRange, rzRange) : 
 //          thirdHitMap[il]->loop();
 
       thirdHits.clear();
       thirdHitMap[il]->hits(phiRange.min(),phiRange.max(), thirdHits);
   
       static float nSigmaRZ = std::sqrt(12.f);
       static float nSigmaPhi = 3.f;
    
       typedef vector<Hit>::const_iterator IH;
       for (IH th=thirdHits.begin(), eh=thirdHits.end(); th !=eh; ++th) {
 
         if (theMaxElement!=0 && result.size() >= theMaxElement){
       result.clear();
       edm::LogError("TooManyTriplets")<<" number of triples exceed maximum. no triplets produced.";
       return;
     }
         const Hit& hit = (*th);
         GlobalPoint point(hit->globalPosition().x()-region.origin().x(),
                           hit->globalPosition().y()-region.origin().y(),
                           hit->globalPosition().z() ); 
         float p3_r = point.perp();
         float p3_z = point.z();
         float p3_phi = point.phi();
  
         if (barrelLayer) {
           Range allowedZ = predictionRZ(p3_r);
           correction.correctRZRange(allowedZ);
 
           float zErr = nSigmaRZ * hit->errorGlobalZ();
           Range hitRange(p3_z-zErr, p3_z+zErr);
           Range crossingRange = allowedZ.intersection(hitRange);
           if (crossingRange.empty())  continue;
         } else {
           Range allowedR = predictionRZ(p3_z);
           correction.correctRZRange(allowedR); 
           float rErr = nSigmaRZ * hit->errorGlobalR();
           Range hitRange(p3_r-rErr, p3_r+rErr);
           Range crossingRange = allowedR.intersection(hitRange);
           if (crossingRange.empty())  continue;
         }
 
     float phiErr = nSigmaPhi*hit->errorGlobalRPhi()/p3_r;
         for (int icharge=-1; icharge <=1; icharge+=2) {
           Range rangeRPhi = predictionRPhi(p3_r, icharge);
           correction.correctRPhiRange(rangeRPhi);
           if (checkPhiInRange(p3_phi, rangeRPhi.first/p3_r-phiErr, rangeRPhi.second/p3_r+phiErr)) {
         // insert here check with comparitor 
         OrderedHitTriplet hittriplet( (*ip).inner(), (*ip).outer(), hit);
         if(!theComparitor  || theComparitor->compatible(hittriplet,region) ) {
           result.push_back( hittriplet ); 
         } else {
           LogDebug("RejectedTriplet") << "rejected triplet from comparitor " 
                       << hittriplet.outer()->globalPosition().x() << " "
                       << hittriplet.outer()->globalPosition().y() << " "
                       << hittriplet.outer()->globalPosition().z();
         }
         break;
           } 
         }
       } 
     }
   }
 
 }

void PixelTripletHLTGenerator::init	(	const HitPairGenerator &	pairs,
		const std::vector< ctfseeding::SeedingLayer > &	layers,
		LayerCacheType *	layerCache
	)

virtual

Implements HitTripletGeneratorFromPairAndLayers.

Definition at line 52 of file PixelTripletHLTGenerator.cc.

References HitPairGenerator::clone(), theLayerCache, theLayers, and thePairGenerator.

 {
   thePairGenerator = pairs.clone();
   theLayers = layers;
   theLayerCache = layerCache;
 }

std::pair< float, float > PixelTripletHLTGenerator::mergePhiRanges	(	const std::pair< float, float > &	r1,
		const std::pair< float, float > &	r2
	)		const

private

Definition at line 228 of file PixelTripletHLTGenerator.cc.

References Geom::fpi(), Geom::ftwoPi(), max(), and min.

Referenced by hitTriplets().

 {
   float r2_min=r2.first;
   float r2_max=r2.second;
   while (r1.first-r2_min > Geom::fpi()) { r2_min += Geom::ftwoPi(); r2_max += Geom::ftwoPi();}
   while (r1.first-r2_min < -Geom::fpi()) { r2_min -= Geom::ftwoPi();  r2_max -= Geom::ftwoPi(); }
   
   return std::make_pair(min(r1.first,r2_min),max(r1.second,r2_max));
 }