#include <HitPairGeneratorFromLayerPair.h>

Public Types
typedef SeedingLayerSetsHits::SeedingLayer	Layer

typedef LayerHitMapCache	LayerCacheType

typedef SeedingLayerSetsHits::SeedingLayerSet	Layers

Public Member Functions
HitDoublets	doublets (const TrackingRegion &reg, const edm::Event &ev, const edm::EventSetup &es, Layers layers)

	HitPairGeneratorFromLayerPair (unsigned int inner, unsigned int outer, LayerCacheType *layerCache, unsigned int max=0)

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

Layer	innerLayer (const Layers &layers) const

Layer	outerLayer (const Layers &layers) const

	~HitPairGeneratorFromLayerPair ()

Private Attributes
const unsigned int	theInnerLayer

LayerCacheType &	theLayerCache

const unsigned int	theMaxElement

const unsigned int	theOuterLayer

Detailed Description

Definition at line 11 of file HitPairGeneratorFromLayerPair.h.

Member Typedef Documentation

typedef SeedingLayerSetsHits::SeedingLayer HitPairGeneratorFromLayerPair::Layer

Definition at line 17 of file HitPairGeneratorFromLayerPair.h.

typedef LayerHitMapCache HitPairGeneratorFromLayerPair::LayerCacheType

Definition at line 15 of file HitPairGeneratorFromLayerPair.h.

typedef SeedingLayerSetsHits::SeedingLayerSet HitPairGeneratorFromLayerPair::Layers

Definition at line 16 of file HitPairGeneratorFromLayerPair.h.

Constructor & Destructor Documentation

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

Definition at line 32 of file HitPairGeneratorFromLayerPair.cc.

   : theLayerCache(*layerCache), theOuterLayer(outer), theInnerLayer(inner), theMaxElement(max)
 {
 }

HitPairGeneratorFromLayerPair::~HitPairGeneratorFromLayerPair ( )

Definition at line 41 of file HitPairGeneratorFromLayerPair.cc.

41 {}

Member Function Documentation

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

Definition at line 90 of file HitPairGeneratorFromLayerPair.cc.

Referenced by hitPairs().

                                                                                                  {
 
   typedef OrderedHitPair::InnerRecHit InnerHit;
   typedef OrderedHitPair::OuterRecHit OuterHit;
   typedef RecHitsSortedInPhi::Hit Hit;
 
   Layer innerLayerObj = innerLayer(layers);
   Layer outerLayerObj = outerLayer(layers);
 
   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();
   result.shrink_to_fit();
   return result;
 }

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

Definition at line 75 of file HitPairGeneratorFromLayerPair.cc.

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

                                                                                              {
 
   auto const & ds = doublets(region, iEvent, iSetup, layers);
   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";
   }
 }