#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 (edm::ConsumesCollector iC, 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 MagneticField &field, const MultipleScatteringParametrisationMaker &msmaker, const unsigned int theMaxElement, HitDoublets &result)

Private Attributes
const edm::ESGetToken < MagneticField, IdealMagneticFieldRecord >	theFieldToken

const unsigned int	theInnerLayer

LayerCacheType *	theLayerCache

const unsigned int	theMaxElement

const edm::ESGetToken < MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord >	theMSMakerToken

const unsigned int	theOuterLayer

Detailed Description

Definition at line 16 of file HitPairGeneratorFromLayerPair.h.

Member Typedef Documentation

typedef SeedingLayerSetsHits::SeedingLayer HitPairGeneratorFromLayerPair::Layer

Definition at line 20 of file HitPairGeneratorFromLayerPair.h.

typedef LayerHitMapCache HitPairGeneratorFromLayerPair::LayerCacheType

Definition at line 18 of file HitPairGeneratorFromLayerPair.h.

typedef SeedingLayerSetsHits::SeedingLayerSet HitPairGeneratorFromLayerPair::Layers

Definition at line 19 of file HitPairGeneratorFromLayerPair.h.

Constructor & Destructor Documentation

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

Definition at line 35 of file HitPairGeneratorFromLayerPair.cc.

     : theLayerCache(layerCache),
       theFieldToken(iC.esConsumes()),
       theMSMakerToken(iC.esConsumes()),
       theOuterLayer(outer),
       theInnerLayer(inner),
       theMaxElement(max) {}

HitPairGeneratorFromLayerPair::~HitPairGeneratorFromLayerPair ( )

Definition at line 44 of file HitPairGeneratorFromLayerPair.cc.

44 {}

Member Function Documentation

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

inline

Definition at line 30 of file HitPairGeneratorFromLayerPair.h.

References cms::cuda::assert(), and 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 34 of file HitPairGeneratorFromLayerPair.h.

References cms::cuda::assert(), 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 42 of file HitPairGeneratorFromLayerPair.h.

References doublets(), innerLayer(), and outerLayer().

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

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

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

void HitPairGeneratorFromLayerPair::doublets	(	const TrackingRegion &	region,
		const DetLayer &	innerHitDetLayer,
		const DetLayer &	outerHitDetLayer,
		const RecHitsSortedInPhi &	innerHitsMap,
		const RecHitsSortedInPhi &	outerHitsMap,
		const MagneticField &	field,
		const MultipleScatteringParametrisationMaker &	msmaker,
		const unsigned int	theMaxElement,
		HitDoublets &	result
	)

static

Definition at line 121 of file HitPairGeneratorFromLayerPair.cc.

                                                                   {
   //  HitDoublets result(innerHitsMap,outerHitsMap); result.reserve(std::max(innerHitsMap.size(),outerHitsMap.size()));
   typedef RecHitsSortedInPhi::Hit Hit;
   InnerDeltaPhi deltaPhi(outerHitDetLayer, innerHitDetLayer, region, field, msmaker);
 
   // 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;
 
     std::unique_ptr<const HitRZCompatibility> checkRZ =
         region.checkRZ(&innerHitDetLayer,
                        ohit,
                        &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];
       if (e == b)
         continue;
       bool ok[e - b];
       switch (checkRZ->algo()) {
         case (HitRZCompatibility::zAlgo):
           std::get<0>(kernels).set(checkRZ.get());
           std::get<0>(kernels)(b, e, innerHitsMap, ok);
           break;
         case (HitRZCompatibility::rAlgo):
           std::get<1>(kernels).set(checkRZ.get());
           std::get<1>(kernels)(b, e, innerHitsMap, ok);
           break;
         case (HitRZCompatibility::etaAlgo):
           std::get<2>(kernels).set(checkRZ.get());
           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";
           return;
         }
         result.add(b + i, io);
       }
     }
   }
   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 76 of file HitPairGeneratorFromLayerPair.cc.

References doublets(), mps_fire::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";
   }
 }