#include <HitPairGeneratorFromLayerPair.h>

Inheritance diagram for HitPairGeneratorFromLayerPair:

Public Types
typedef SeedingLayerSetsHits::SeedingLayer	Layer

typedef CombinedHitPairGenerator::LayerCacheType	LayerCacheType

typedef SeedingLayerSetsHits::SeedingLayerSet	Layers

Public Member Functions
virtual HitPairGeneratorFromLayerPair *	clone () const

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

	HitPairGeneratorFromLayerPair (unsigned int inner, unsigned int 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)

Layer	innerLayer () const

Layer	outerLayer () const

void	setSeedingLayers (Layers layers) override

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
const unsigned int	theInnerLayer

LayerCacheType &	theLayerCache

const unsigned int	theOuterLayer

Layers	theSeedingLayers

Additional Inherited Members
Public Attributes inherited from OrderedHitsGenerator
unsigned int	theMaxElement

Detailed Description

Definition at line 10 of file HitPairGeneratorFromLayerPair.h.

Member Typedef Documentation

typedef SeedingLayerSetsHits::SeedingLayer HitPairGeneratorFromLayerPair::Layer

Definition at line 16 of file HitPairGeneratorFromLayerPair.h.

typedef CombinedHitPairGenerator::LayerCacheType HitPairGeneratorFromLayerPair::LayerCacheType

Definition at line 14 of file HitPairGeneratorFromLayerPair.h.

typedef SeedingLayerSetsHits::SeedingLayerSet HitPairGeneratorFromLayerPair::Layers

Definition at line 15 of file HitPairGeneratorFromLayerPair.h.

Constructor & Destructor Documentation

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

Definition at line 32 of file HitPairGeneratorFromLayerPair.cc.

References bookConverter::max, and OrderedHitsGenerator::theMaxElement.

Referenced by clone().

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

virtual HitPairGeneratorFromLayerPair::~HitPairGeneratorFromLayerPair ( )

inlinevirtual

Definition at line 24 of file HitPairGeneratorFromLayerPair.h.

24 { }

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 92 of file HitPairGeneratorFromLayerPair.cc.

Referenced by hitPairs().

                                                                                   {
 
   typedef OrderedHitPair::InnerRecHit InnerHit;
   typedef OrderedHitPair::OuterRecHit OuterHit;
   typedef RecHitsSortedInPhi::Hit Hit;
 
   Layer innerLayerObj = innerLayer();
   Layer outerLayerObj = outerLayer();
 
   const RecHitsSortedInPhi & innerHitsMap = theLayerCache(innerLayerObj, region, iEvent, iSetup);
   if (innerHitsMap.empty()) return HitDoublets(innerHitsMap,innerHitsMap);
 
   const RecHitsSortedInPhi& outerHitsMap = theLayerCache(outerLayerObj, region, iEvent, iSetup);
   if (outerHitsMap.empty()) return HitDoublets(innerHitsMap,outerHitsMap);
 
   HitDoublets result(innerHitsMap,outerHitsMap); result.reserve(std::max(innerHitsMap.size(),outerHitsMap.size()));
 
   InnerDeltaPhi deltaPhi(*outerLayerObj.detLayer(), *innerLayerObj.detLayer(), region, iSetup);
 
   // std::cout << "layers " << theInnerLayer.detLayer()->seqNum()  << " " << outerLayer.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(innerLayerObj.detLayer(), ohit, iSetup, outerLayerObj.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 77 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";
   }
 }