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

HitDoublets	doublets (const TrackingRegion &reg, const edm::Event &ev, const edm::EventSetup &es, const Layer &innerLayer, const Layer &outerLayer)

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

HitDoublets	doublets (const TrackingRegion &reg, const edm::Event &ev, const edm::EventSetup &es, const Layer &innerLayer, const Layer &outerLayer, LayerCacheType &layerCache)

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

Static Public Member Functions
static void	doublets (const TrackingRegion &region, const DetLayer &innerHitDetLayer, const DetLayer &outerHitDetLayer, const RecHitsSortedInPhi &innerHitsMap, const RecHitsSortedInPhi &outerHitsMap, const edm::EventSetup &iSetup, const unsigned int theMaxElement, HitDoublets &result)

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.

References a, b, CustomConfigs::Base(), constexpr, RecHitsSortedInPhi::dv, MillePedeFileConverter_cfg::e, PixelRecoRange< T >::empty(), mps_fire::i, PixelRecoRange< T >::intersection(), nSigmaRZ, convertSQLiteXML::ok, RecHitsSortedInPhi::u, and RecHitsSortedInPhi::v.

41 {}

Member Function Documentation

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

inline

Definition at line 26 of file HitPairGeneratorFromLayerPair.h.

References theLayerCache.

Referenced by doublets(), hitPairs(), and SeedFinderSelector::pass().

                                                                                       {
     assert(theLayerCache);
     return doublets(reg, ev, es, layers, *theLayerCache);
   }

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

inline

Definition at line 31 of file HitPairGeneratorFromLayerPair.h.

References doublets(), and theLayerCache.

                                                                                                                          {
     assert(theLayerCache);
     return doublets(reg, ev, es, innerLayer, outerLayer, *theLayerCache);
   }

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

inline

Definition at line 36 of file HitPairGeneratorFromLayerPair.h.

References doublets(), ev, hitPairs(), innerLayer(), LayerTriplets::layers(), outerLayer(), mps_fire::result, and theMaxElement.

                                                                                                                  {
     Layer innerLayerObj = innerLayer(layers);
     Layer outerLayerObj = outerLayer(layers);
     return doublets(reg, ev, es, innerLayerObj, outerLayerObj, layerCache);
   }

HitDoublets HitPairGeneratorFromLayerPair::doublets	(	const TrackingRegion &	reg,
		const edm::Event &	ev,
		const edm::EventSetup &	es,
		const Layer &	innerLayer,
		const Layer &	outerLayer,
		LayerCacheType &	layerCache
	)

Definition at line 89 of file HitPairGeneratorFromLayerPair.cc.

References SeedingLayerSetsHits::SeedingLayer::detLayer(), doublets(), RecHitsSortedInPhi::empty(), SiStripPI::max, HitDoublets::reserve(), mps_fire::result, RecHitsSortedInPhi::size(), and theMaxElement.

                                                                                  {
 
   const RecHitsSortedInPhi & innerHitsMap = layerCache(innerLayer, region, iSetup);
   if (innerHitsMap.empty()) return HitDoublets(innerHitsMap,innerHitsMap);
 
   const RecHitsSortedInPhi& outerHitsMap = layerCache(outerLayer, region, iSetup);
   if (outerHitsMap.empty()) return HitDoublets(innerHitsMap,outerHitsMap);
   HitDoublets result(innerHitsMap,outerHitsMap); result.reserve(std::max(innerHitsMap.size(),outerHitsMap.size()));
   doublets(region,
        *innerLayer.detLayer(),*outerLayer.detLayer(),
        innerHitsMap,outerHitsMap,iSetup,theMaxElement,result);
   
   return result;
 
 }

void HitPairGeneratorFromLayerPair::doublets	(	const TrackingRegion &	region,
		const DetLayer &	innerHitDetLayer,
		const DetLayer &	outerHitDetLayer,
		const RecHitsSortedInPhi &	innerHitsMap,
		const RecHitsSortedInPhi &	outerHitsMap,
		const edm::EventSetup &	iSetup,
		const unsigned int	theMaxElement,
		HitDoublets &	result
	)

static

Definition at line 107 of file HitPairGeneratorFromLayerPair.cc.

References HitDoublets::add(), HitRZCompatibility::algo(), b, TrackingRegion::checkRZ(), HitDoublets::clear(), constexpr, hiPixelPairStep_cff::deltaPhi, RecHitsSortedInPhi::doubleRange(), RecHitsSortedInPhi::drphi, RecHitsSortedInPhi::du, RecHitsSortedInPhi::dv, MillePedeFileConverter_cfg::e, PixelRecoRange< T >::empty(), HitRZCompatibility::etaAlgo, mps_fire::i, createfilelist::int, RecHitsSortedInPhi::isBarrel, LogDebug, PixelRecoRange< T >::max(), PixelRecoRange< T >::min(), nSigmaPhi, convertSQLiteXML::ok, InnerDeltaPhi::prefilter(), HitRZCompatibility::rAlgo, RecHitsSortedInPhi::rv(), HitDoublets::shrink_to_fit(), HitDoublets::size(), RecHitsSortedInPhi::theHits, theMaxElement, RecHitsSortedInPhi::x, RecHitsSortedInPhi::y, RecHitsSortedInPhi::z, and HitRZCompatibility::zAlgo.

                                                  {
 
   //  HitDoublets result(innerHitsMap,outerHitsMap); result.reserve(std::max(innerHitsMap.size(),outerHitsMap.size()));
   typedef RecHitsSortedInPhi::Hit Hit;
   InnerDeltaPhi deltaPhi(outerHitDetLayer, innerHitDetLayer, 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) {
     if (!deltaPhi.prefilter(outerHitsMap.x[io],outerHitsMap.y[io])) continue;
     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(&innerHitDetLayer, ohit, iSetup, &outerHitDetLayer, 
                                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.add(b+i,io);
       }
     }
     delete checkRZ;
   }
   LogDebug("HitPairGeneratorFromLayerPair")<<" total number of pairs provided back: "<<result.size();
   result.shrink_to_fit();
 
 }

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(), mps_fire::i, HitDoublets::inner, HitDoublets::outer, OrderedHitPairs::size(), and theMaxElement.

Referenced by doublets().

                                                                                              {
 
   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";
   }
 }