#include <HitPairGeneratorFromLayerPair.h>

Inheritance diagram for HitPairGeneratorFromLayerPair:

Public Types
typedef ctfseeding::SeedingLayer	Layer

typedef CombinedHitPairGenerator::LayerCacheType	LayerCacheType

Public Member Functions
virtual HitPairGeneratorFromLayerPair *	clone () const

virtual HitDoublets	doublets (const TrackingRegion &reg, const edm::Event &ev, const edm::EventSetup &es)

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

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

Public Member Functions inherited from HitPairGenerator
virtual void	clear ()

	HitPairGenerator (unsigned int size=7500)

virtual void	hitPairs (const TrackingRegion &reg, OrderedHitPairs &prs, const edm::EventSetup &es)

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

virtual	~HitPairGenerator ()

Public Member Functions inherited from OrderedHitsGenerator
	OrderedHitsGenerator ()

virtual	~OrderedHitsGenerator ()

Private Attributes
Layer const	theInnerLayer

LayerCacheType &	theLayerCache

Layer const	theOuterLayer

Additional Inherited Members
Public Attributes inherited from OrderedHitsGenerator
unsigned int	theMaxElement

Detailed Description

Definition at line 12 of file HitPairGeneratorFromLayerPair.h.

Member Typedef Documentation

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.

Constructor & Destructor Documentation

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

Definition at line 35 of file HitPairGeneratorFromLayerPair.cc.

References max(), and OrderedHitsGenerator::theMaxElement.

Referenced by clone().

   : HitPairGenerator(nSize),
     theLayerCache(*layerCache), theOuterLayer(outer), theInnerLayer(inner)
 {
   theMaxElement=max;
 }

virtual HitPairGeneratorFromLayerPair::~HitPairGeneratorFromLayerPair ( )

inlinevirtual

Definition at line 25 of file HitPairGeneratorFromLayerPair.h.

25 { }

Member Function Documentation

virtual HitPairGeneratorFromLayerPair* HitPairGeneratorFromLayerPair::clone ( void ) const

inlinevirtual

Implements HitPairGenerator.

Definition at line 34 of file HitPairGeneratorFromLayerPair.h.

References HitPairGeneratorFromLayerPair().

                                                        {
     return new HitPairGeneratorFromLayerPair(*this);
   }

HitDoublets HitPairGeneratorFromLayerPair::doublets	(	const TrackingRegion &	reg,
		const edm::Event &	ev,
		const edm::EventSetup &	es
	)

virtual

Reimplemented from HitPairGenerator.

Definition at line 96 of file HitPairGeneratorFromLayerPair.cc.

Referenced by hitPairs().

                                                                                   {
 
   typedef OrderedHitPair::InnerRecHit InnerHit;
   typedef OrderedHitPair::OuterRecHit OuterHit;
   typedef RecHitsSortedInPhi::Hit Hit;
 
   const RecHitsSortedInPhi & innerHitsMap = theLayerCache(&theInnerLayer, region, iEvent, iSetup);
   if (innerHitsMap.empty()) return HitDoublets(innerHitsMap,innerHitsMap);
  
   const RecHitsSortedInPhi& outerHitsMap = theLayerCache(&theOuterLayer, region, iEvent, iSetup);
   if (outerHitsMap.empty()) return HitDoublets(innerHitsMap,outerHitsMap);
 
   HitDoublets result(innerHitsMap,outerHitsMap); result.reserve(std::max(innerHitsMap.size(),outerHitsMap.size()));
 
   InnerDeltaPhi deltaPhi(*theOuterLayer.detLayer(), *theInnerLayer.detLayer(), region, iSetup);
 
   // std::cout << "layers " << theInnerLayer.detLayer()->seqNum()  << " " << theOuterLayer.detLayer()->seqNum() << std::endl;
 
   // constexpr float nSigmaRZ = std::sqrt(12.f);
   constexpr float nSigmaPhi = 3.f;
   for (int io = 0; io!=int(outerHitsMap.theHits.size()); ++io) { 
     Hit const & ohit =  outerHitsMap.theHits[io].hit();
     PixelRecoRange<float> phiRange = deltaPhi(outerHitsMap.x[io], 
                           outerHitsMap.y[io], 
                           outerHitsMap.z[io], 
                           nSigmaPhi*outerHitsMap.drphi[io]
                           );    
 
     if (phiRange.empty()) continue;
 
     const HitRZCompatibility *checkRZ = region.checkRZ(theInnerLayer.detLayer(), ohit, iSetup,theOuterLayer.detLayer(), 
                                outerHitsMap.rv(io),outerHitsMap.z[io],
                                outerHitsMap.isBarrel ? outerHitsMap.du[io] :  outerHitsMap.dv[io],
                                outerHitsMap.isBarrel ? outerHitsMap.dv[io] :  outerHitsMap.du[io]
                                );
     if(!checkRZ) continue;
 
     Kernels<HitZCheck,HitRCheck,HitEtaCheck> kernels;
 
     auto innerRange = innerHitsMap.doubleRange(phiRange.min(), phiRange.max());
     LogDebug("HitPairGeneratorFromLayerPair")<<
       "preparing for combination of: "<< innerRange[1]-innerRange[0]+innerRange[3]-innerRange[2]
                       <<" inner and: "<< outerHitsMap.theHits.size()<<" outter";
     for(int j=0; j<3; j+=2) {
       auto b = innerRange[j]; auto e=innerRange[j+1];
       bool ok[e-b];
       switch (checkRZ->algo()) {
     case (HitRZCompatibility::zAlgo) :
       std::get<0>(kernels).set(checkRZ);
       std::get<0>(kernels)(b,e,innerHitsMap, ok);
       break;
     case (HitRZCompatibility::rAlgo) :
       std::get<1>(kernels).set(checkRZ);
       std::get<1>(kernels)(b,e,innerHitsMap, ok);
       break;
     case (HitRZCompatibility::etaAlgo) :
       std::get<2>(kernels).set(checkRZ);
       std::get<2>(kernels)(b,e,innerHitsMap, ok);
       break;
       }
       for (int i=0; i!=e-b; ++i) {
     if (!ok[i]) continue;
     if (theMaxElement!=0 && result.size() >= theMaxElement){
       result.clear();
       edm::LogError("TooManyPairs")<<"number of pairs exceed maximum, no pairs produced";
       delete checkRZ;
       return result;
     }
         result.add(b+i,io);
       }
     }
     delete checkRZ;
   }
   LogDebug("HitPairGeneratorFromLayerPair")<<" total number of pairs provided back: "<<result.size();
   return result;
 }

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

virtual

Implements HitPairGenerator.

Definition at line 81 of file HitPairGeneratorFromLayerPair.cc.

References doublets(), i, HitDoublets::inner, HitDoublets::outer, OrderedHitPairs::size(), and OrderedHitsGenerator::theMaxElement.

                                                                               {
   
   auto const & ds = doublets(region,iEvent,iSetup);
   for (std::size_t i=0; i!=ds.size(); ++i) {
     result.push_back( OrderedHitPair( ds.hit(i,HitDoublets::inner),ds.hit(i,HitDoublets::outer) ));
   }
   if (theMaxElement!=0 && result.size() >= theMaxElement){
      result.clear();
     edm::LogError("TooManyPairs")<<"number of pairs exceed maximum, no pairs produced";
   }
 }