#include <CAHitQuadrupletGenerator.h>

Inheritance diagram for CAHitQuadrupletGenerator:

Classes
class	QuantityDependsPt

class	QuantityDependsPtEval

Public Types
typedef LayerHitMapCache	LayerCacheType

typedef OrderedHitSeeds	ResultType

Public Member Functions
	CAHitQuadrupletGenerator (const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC, bool needSeedingLayerSetsHits=true)

	CAHitQuadrupletGenerator (const edm::ParameterSet &cfg, edm::ConsumesCollector &iC, bool needSeedingLayerSetsHits=true)

void	hitNtuplets (const IntermediateHitDoublets::RegionLayerSets &regionLayerPairs, OrderedHitSeeds &result, const edm::EventSetup &es, const SeedingLayerSetsHits &layers)

virtual void	hitQuadruplets (const TrackingRegion &reg, OrderedHitSeeds &quadruplets, const edm::Event &ev, const edm::EventSetup &es)
	from base class More...

void	initEvent (const edm::Event &ev, const edm::EventSetup &es)

virtual	~CAHitQuadrupletGenerator ()

Public Member Functions inherited from HitQuadrupletGenerator
virtual void	clear () final

	HitQuadrupletGenerator (unsigned int size=500)

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

virtual	~HitQuadrupletGenerator ()

Public Member Functions inherited from OrderedHitsGenerator
	OrderedHitsGenerator ()

virtual	~OrderedHitsGenerator ()

Static Public Member Functions
static void	fillDescriptions (edm::ParameterSetDescription &desc)

static const char *	fillDescriptionsLabel ()

Static Public Attributes
static unsigned int	minLayers = 4

Private Member Functions
void	hitQuadruplets (const TrackingRegion &reg, OrderedHitSeeds &result, std::vector< const HitDoublets * > &hitDoublets, const CAGraph &g, const edm::EventSetup &es)

Private Attributes
const float	caHardPtCut = 0.f

const bool	caOnlyOneLastHitPerLayerFilter = false

const float	caPhiCut = 0.1f

const float	caThetaCut = 0.00125f

const float	extraHitRPhitolerance

const bool	fitFastCircle

const bool	fitFastCircleChi2Cut

const QuantityDependsPt	maxChi2

std::unique_ptr< SeedComparitor >	theComparitor

LayerCacheType	theLayerCache

edm::EDGetTokenT < SeedingLayerSetsHits >	theSeedingLayerToken

const bool	useBendingCorrection

Additional Inherited Members
Public Attributes inherited from OrderedHitsGenerator
unsigned int	theMaxElement

Detailed Description

Definition at line 32 of file CAHitQuadrupletGenerator.h.

Member Typedef Documentation

typedef LayerHitMapCache CAHitQuadrupletGenerator::LayerCacheType

Definition at line 34 of file CAHitQuadrupletGenerator.h.

typedef OrderedHitSeeds CAHitQuadrupletGenerator::ResultType

Definition at line 37 of file CAHitQuadrupletGenerator.h.

Constructor & Destructor Documentation

CAHitQuadrupletGenerator::CAHitQuadrupletGenerator	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	iC,
		bool	needSeedingLayerSetsHits = `true`
	)

inline

Definition at line 41 of file CAHitQuadrupletGenerator.h.

41 : CAHitQuadrupletGenerator(cfg, iC, needSeedingLayerSetsHits) {}

CAHitQuadrupletGenerator::CAHitQuadrupletGenerator

CAHitQuadrupletGenerator(const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC, bool needSeedingLayerSetsHits=true)

Definition: CAHitQuadrupletGenerator.h:41

CAHitQuadrupletGenerator::CAHitQuadrupletGenerator	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &	iC,
		bool	needSeedingLayerSetsHits = `true`
	)

Definition at line 46 of file CAHitQuadrupletGenerator.cc.

References edm::ConsumesCollector::consumes(), beamerCreator::create(), edm::ParameterSet::exists(), reco::get(), edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, theComparitor, and theSeedingLayerToken.

                                                                                                                                       :
 extraHitRPhitolerance(cfg.getParameter<double>("extraHitRPhitolerance")), //extra window in ThirdHitPredictionFromCircle range (divide by R to get phi)
 maxChi2(cfg.getParameter<edm::ParameterSet>("maxChi2")),
 fitFastCircle(cfg.getParameter<bool>("fitFastCircle")),
 fitFastCircleChi2Cut(cfg.getParameter<bool>("fitFastCircleChi2Cut")),
 useBendingCorrection(cfg.getParameter<bool>("useBendingCorrection")),
 caThetaCut(cfg.getParameter<double>("CAThetaCut")),
 caPhiCut(cfg.getParameter<double>("CAPhiCut")),
 caHardPtCut(cfg.getParameter<double>("CAHardPtCut")),
 caOnlyOneLastHitPerLayerFilter(cfg.getParameter<bool>("CAOnlyOneLastHitPerLayerFilter"))
 {
   if(needSeedingLayerSetsHits)
     theSeedingLayerToken = iC.consumes<SeedingLayerSetsHits>(cfg.getParameter<edm::InputTag>("SeedingLayers"));
 
   if (cfg.exists("SeedComparitorPSet"))
   {
     edm::ParameterSet comparitorPSet =
             cfg.getParameter<edm::ParameterSet>("SeedComparitorPSet");
     std::string comparitorName = comparitorPSet.getParameter<std::string>("ComponentName");
     if (comparitorName != "none")
     {
       theComparitor.reset(SeedComparitorFactory::get()->create(comparitorName, comparitorPSet, iC));
     }
   }
 }

CAHitQuadrupletGenerator::~CAHitQuadrupletGenerator ( )

virtual

Definition at line 72 of file CAHitQuadrupletGenerator.cc.

73 {

74 }

Member Function Documentation

void CAHitQuadrupletGenerator::fillDescriptions ( edm::ParameterSetDescription & desc )

static

Definition at line 76 of file CAHitQuadrupletGenerator.cc.

References edm::ParameterSetDescription::add(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                 {
   desc.add<double>("extraHitRPhitolerance", 0.1);
   desc.add<bool>("fitFastCircle", false);
   desc.add<bool>("fitFastCircleChi2Cut", false);
   desc.add<bool>("useBendingCorrection", false);
   desc.add<double>("CAThetaCut", 0.00125);
   desc.add<double>("CAPhiCut", 10);
   desc.add<double>("CAHardPtCut", 0);
   desc.add<bool>("CAOnlyOneLastHitPerLayerFilter",false);
   edm::ParameterSetDescription descMaxChi2;
   descMaxChi2.add<double>("pt1", 0.2);
   descMaxChi2.add<double>("pt2", 1.5);
   descMaxChi2.add<double>("value1", 500);
   descMaxChi2.add<double>("value2", 50);
   descMaxChi2.add<bool>("enabled", true);
   desc.add<edm::ParameterSetDescription>("maxChi2", descMaxChi2);
 
   edm::ParameterSetDescription descComparitor;
   descComparitor.add<std::string>("ComponentName", "none");
   descComparitor.setAllowAnything(); // until we have moved SeedComparitor too to EDProducers
   desc.add<edm::ParameterSetDescription>("SeedComparitorPSet", descComparitor);
 }

static const char* CAHitQuadrupletGenerator::fillDescriptionsLabel ( )

inlinestatic

Definition at line 47 of file CAHitQuadrupletGenerator.h.

47 { return "caHitQuadruplet"; }

void CAHitQuadrupletGenerator::hitNtuplets	(	const IntermediateHitDoublets::RegionLayerSets &	regionLayerPairs,
		OrderedHitSeeds &	result,
		const edm::EventSetup &	es,
		const SeedingLayerSetsHits &	layers
	)

Definition at line 206 of file CAHitQuadrupletGenerator.cc.

References ihd::RegionLayerSets< T >::begin(), ihd::RegionLayerSets< T >::end(), newFWLiteAna::found, g, hitQuadruplets(), SeedingLayerSetsHits::SeedingLayer::index(), SurfaceOrientation::inner, IntermediateHitDoublets::LayerPairHitDoublets::innerLayerIndex(), SurfaceOrientation::outer, IntermediateHitDoublets::LayerPairHitDoublets::outerLayerIndex(), ihd::RegionLayerSets< T >::region(), and mps_fire::result.

                                                                                   {
   CAGraph g;
 
   std::vector<const HitDoublets *> hitDoublets;
 
   auto layerPairEqual = [](const IntermediateHitDoublets::LayerPairHitDoublets& pair,
                            SeedingLayerSetsHits::LayerIndex inner,
                            SeedingLayerSetsHits::LayerIndex outer) {
     return pair.innerLayerIndex() == inner && pair.outerLayerIndex() == outer;
   };
   fillGraph(layers, g, hitDoublets,
             [&](const SeedingLayerSetsHits::SeedingLayer& inner,
                 const SeedingLayerSetsHits::SeedingLayer& outer,
                 std::vector<const HitDoublets *>& hitDoublets) {
       using namespace std::placeholders;
       auto found = std::find_if(regionLayerPairs.begin(), regionLayerPairs.end(),
                                 std::bind(layerPairEqual, _1, inner.index(), outer.index()));
       if(found != regionLayerPairs.end()) {
         hitDoublets.emplace_back(&(found->doublets()));
         return true;
       }
       return false;
     });
 
   hitQuadruplets(regionLayerPairs.region(), result, hitDoublets, g, es);
 }

void CAHitQuadrupletGenerator::hitQuadruplets	(	const TrackingRegion &	reg,
		OrderedHitSeeds &	quadruplets,
		const edm::Event &	ev,
		const edm::EventSetup &	es
	)

virtual

from base class

Implements HitQuadrupletGenerator.

Definition at line 167 of file CAHitQuadrupletGenerator.cc.

References LayerHitMapCache::clear(), HitPairGeneratorFromLayerPair::doublets(), alignCSCRings::e, g, edm::Event::getByToken(), SurfaceOrientation::inner, SeedingLayerSetsHits::numberOfLayersInSet(), SurfaceOrientation::outer, theComparitor, theLayerCache, and theSeedingLayerToken.

Referenced by hitNtuplets().

 {
     edm::Handle<SeedingLayerSetsHits> hlayers;
     ev.getByToken(theSeedingLayerToken, hlayers);
     const SeedingLayerSetsHits& layers = *hlayers;
     if (layers.numberOfLayersInSet() != 4)
         throw cms::Exception("Configuration")
                 << "CAHitQuadrupletsGenerator expects SeedingLayerSetsHits::numberOfLayersInSet() to be 4, got "
                 << layers.numberOfLayersInSet();
 
     CAGraph g;
 
 
     std::vector<HitDoublets> hitDoublets;
 
 
     HitPairGeneratorFromLayerPair thePairGenerator(0, 1, &theLayerCache);
         fillGraph(layers, g, hitDoublets,
                   [&](const SeedingLayerSetsHits::SeedingLayer& inner,
                       const SeedingLayerSetsHits::SeedingLayer& outer,
                       std::vector<HitDoublets>& hitDoublets) {
             hitDoublets.emplace_back(thePairGenerator.doublets(region, ev, es, inner, outer));
             return true;
           });
 
     if (theComparitor)
         theComparitor->init(ev, es);
 
         std::vector<const HitDoublets *> hitDoubletsPtr;
         hitDoubletsPtr.reserve(hitDoublets.size());
         for(const auto& e: hitDoublets)
           hitDoubletsPtr.emplace_back(&e);
 
         hitQuadruplets(region, result, hitDoubletsPtr, g, es);
         theLayerCache.clear();
 }

void CAHitQuadrupletGenerator::hitQuadruplets	(	const TrackingRegion &	reg,
		OrderedHitSeeds &	result,
		std::vector< const HitDoublets * > &	hitDoublets,
		const CAGraph &	g,
		const edm::EventSetup &	es
	)

private

Definition at line 236 of file CAHitQuadrupletGenerator.cc.

References funct::abs(), EnergyCorrector::c, caHardPtCut, caOnlyOneLastHitPerLayerFilter, caPhiCut, caThetaCut, FastCircleFit::chi2(), RZLine::chi2(), beam_dqm_sourceclient-live_cfg::chi2, CellularAutomaton::createAndConnectCells(), ThirdHitPredictionFromCircle::curvature(), PixelRecoUtilities::curvature(), GlobalErrorBase< T, ErrorWeightType >::czz(), relativeConstraints::error, CAHitQuadrupletGenerator::QuantityDependsPt::evaluator(), CellularAutomaton::evolve(), extraHitRPhitolerance, CellularAutomaton::findNtuplets(), fitFastCircle, fitFastCircleChi2Cut, edm::EventSetup::get(), i, PixelRecoUtilities::inversePt(), GeomDetEnumerators::isBarrel(), edm::isNotFinite(), TrackerTopology::layer(), geometryCSVtoXML::line, bookConverter::max, maxChi2, TrackingRegion::origin(), PixelSubdetector::PixelBarrel, point, edm::ESHandle< class >::product(), EnergyCorrector::pt, GlobalErrorBase< T, ErrorWeightType >::rerr(), TrackerTopology::side(), funct::sqr(), mathSSE::sqrt(), GeomDetEnumerators::subDetId, theComparitor, useBendingCorrection, CAHitQuadrupletGenerator::QuantityDependsPtEval::value(), x, PV3DBase< T, PVType, FrameType >::x(), y, PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                        {
     //Retrieve tracker topology from geometry
     edm::ESHandle<TrackerTopology> tTopoHand;
     es.get<TrackerTopologyRcd>().get(tTopoHand);
     const TrackerTopology *tTopo=tTopoHand.product();   
     
     const int numberOfHitsInNtuplet = 4;
     std::vector<CACell::CAntuplet> foundQuadruplets;
 
     CellularAutomaton ca(g);
 
     ca.createAndConnectCells(hitDoublets, region, caThetaCut,
             caPhiCut, caHardPtCut);
 
     ca.evolve(numberOfHitsInNtuplet);
 
     ca.findNtuplets(foundQuadruplets, numberOfHitsInNtuplet);
 
 
     const QuantityDependsPtEval maxChi2Eval = maxChi2.evaluator(es);
 
   // re-used thoughout, need to be vectors because of RZLine interface
   std::array<float, 4> bc_r;
   std::array<float, 4> bc_z;
   std::array<float, 4> bc_errZ2;
   std::array<GlobalPoint, 4> gps;
   std::array<GlobalError, 4> ges;
   std::array<bool, 4> barrels;
   unsigned int fourthLayerId = 0;
   unsigned int previousfourthLayerId = 0;
   int subDetId = 0; 
   int previousSubDetId = 0;
   unsigned int sideId = 0; 
   unsigned int previousSideId = 0; 
   std::array<unsigned int, 2> previousCellIds ={{0,0}};
   bool isTheSameTriplet = false;
   bool isTheSameFourthLayer = false;
   bool hasAlreadyPushedACandidate = false;
   float selectedChi2 = std::numeric_limits<float>::max();
 
 
   unsigned int numberOfFoundQuadruplets = foundQuadruplets.size();
 
   // Loop over quadruplets
   for (unsigned int quadId = 0; quadId < numberOfFoundQuadruplets; ++quadId)
   {
 
     auto isBarrel = [](const unsigned id) -> bool
     {
       return id == PixelSubdetector::PixelBarrel;
     };
     for(unsigned int i = 0; i< 3; ++i)
     {
         auto const& ahit = foundQuadruplets[quadId][i]->getInnerHit();
         gps[i] = ahit->globalPosition();
         ges[i] = ahit->globalPositionError();
         barrels[i] = isBarrel(ahit->geographicalId().subdetId());
     }
 
     auto const& ahit = foundQuadruplets[quadId][2]->getOuterHit();
     gps[3] = ahit->globalPosition();
     ges[3] = ahit->globalPositionError();
     barrels[3] = isBarrel(ahit->geographicalId().subdetId());
 
     if(caOnlyOneLastHitPerLayerFilter)
     {
             fourthLayerId = tTopo->layer(ahit->geographicalId());
             sideId = tTopo->side(ahit->geographicalId());
             subDetId = ahit->geographicalId().subdetId();
         isTheSameTriplet = (quadId != 0) && (foundQuadruplets[quadId][0]->getCellId() ==  previousCellIds[0]) && (foundQuadruplets[quadId][1]->getCellId() ==  previousCellIds[1]);
             isTheSameFourthLayer = (quadId != 0) &&  (fourthLayerId == previousfourthLayerId) && (subDetId == previousSubDetId) && (sideId == previousSideId);
 
         previousCellIds = {{foundQuadruplets[quadId][0]->getCellId(), foundQuadruplets[quadId][1]->getCellId()}};
         previousfourthLayerId = fourthLayerId;
 
 
         if(!(isTheSameTriplet && isTheSameFourthLayer ))
         {
         selectedChi2 = std::numeric_limits<float>::max();
         hasAlreadyPushedACandidate = false;
         }
 
     }
 
 
     // TODO:
     // - 'line' is not used for anything
     // - if we decide to always do the circle fit for 4 hits, we don't
     //   need ThirdHitPredictionFromCircle for the curvature; then we
     //   could remove extraHitRPhitolerance configuration parameter
     PixelRecoLineRZ line(gps[0], gps[2]);
     ThirdHitPredictionFromCircle predictionRPhi(gps[0], gps[2], extraHitRPhitolerance);
     const float curvature = predictionRPhi.curvature(ThirdHitPredictionFromCircle::Vector2D(gps[1].x(), gps[1].y()));
     const float abscurv = std::abs(curvature);
     const float thisMaxChi2 = maxChi2Eval.value(abscurv);
 
     if (theComparitor)
     {
       SeedingHitSet tmpTriplet(foundQuadruplets[quadId][0]->getInnerHit(), foundQuadruplets[quadId][2]->getInnerHit(), foundQuadruplets[quadId][2]->getOuterHit());
 
 
       if (!theComparitor->compatible(tmpTriplet) )
       {
         continue;
       }
     }
 
     float chi2 = std::numeric_limits<float>::quiet_NaN();
     // TODO: Do we have any use case to not use bending correction?
     if (useBendingCorrection)
     {
       // Following PixelFitterByConformalMappingAndLine
       const float simpleCot = ( gps.back().z() - gps.front().z() ) / (gps.back().perp() - gps.front().perp() );
       const float pt = 1.f / PixelRecoUtilities::inversePt(abscurv, es);
       for (int i=0; i < 4; ++i)
       {
         const GlobalPoint & point = gps[i];
         const GlobalError & error = ges[i];
         bc_r[i] = sqrt( sqr(point.x() - region.origin().x()) + sqr(point.y() - region.origin().y()) );
         bc_r[i] += pixelrecoutilities::LongitudinalBendingCorrection(pt, es)(bc_r[i]);
         bc_z[i] = point.z() - region.origin().z();
         bc_errZ2[i] =  (barrels[i]) ? error.czz() : error.rerr(point)*sqr(simpleCot);
       }
       RZLine rzLine(bc_r, bc_z, bc_errZ2, RZLine::ErrZ2_tag());
       chi2 = rzLine.chi2();
     } 
     else
     {
       RZLine rzLine(gps, ges, barrels);
       chi2 = rzLine.chi2();
     }
     if (edm::isNotFinite(chi2) || chi2 > thisMaxChi2)
     {
       continue;
               
     }
     // TODO: Do we have any use case to not use circle fit? Maybe
     // HLT where low-pT inefficiency is not a problem?
     if (fitFastCircle)
     {
       FastCircleFit c(gps, ges);
       chi2 += c.chi2();
       if (edm::isNotFinite(chi2))
         continue;
       if (fitFastCircleChi2Cut && chi2 > thisMaxChi2)
         continue;
     }
 
     if(caOnlyOneLastHitPerLayerFilter)
     {
         if (chi2 < selectedChi2)
         {
         selectedChi2 = chi2;
 
         if(hasAlreadyPushedACandidate)
         {
             result.pop_back();
 
         }
         result.emplace_back(foundQuadruplets[quadId][0]->getInnerHit(), foundQuadruplets[quadId][1]->getInnerHit(),
                 foundQuadruplets[quadId][2]->getInnerHit(), foundQuadruplets[quadId][2]->getOuterHit());
         hasAlreadyPushedACandidate = true;
 
         }
     }
     else
     {
 
        result.emplace_back(foundQuadruplets[quadId][0]->getInnerHit(), foundQuadruplets[quadId][1]->getInnerHit(), foundQuadruplets[quadId][2]->getInnerHit(), foundQuadruplets[quadId][2]->getOuterHit());
     }
      
   }
 
 }

void CAHitQuadrupletGenerator::initEvent	(	const edm::Event &	ev,
		const edm::EventSetup &	es
	)

Definition at line 99 of file CAHitQuadrupletGenerator.cc.

References theComparitor.

                                                                                     {
   if (theComparitor) theComparitor->init(ev, es);
 }

Member Data Documentation

const float CAHitQuadrupletGenerator::caHardPtCut = 0.f

private

Definition at line 148 of file CAHitQuadrupletGenerator.h.

Referenced by hitQuadruplets().

const bool CAHitQuadrupletGenerator::caOnlyOneLastHitPerLayerFilter = false

private

Definition at line 149 of file CAHitQuadrupletGenerator.h.

Referenced by hitQuadruplets().

const float CAHitQuadrupletGenerator::caPhiCut = 0.1f

private

Definition at line 147 of file CAHitQuadrupletGenerator.h.

Referenced by hitQuadruplets().

const float CAHitQuadrupletGenerator::caThetaCut = 0.00125f

private

Definition at line 146 of file CAHitQuadrupletGenerator.h.

Referenced by hitQuadruplets().

const float CAHitQuadrupletGenerator::extraHitRPhitolerance

private

Definition at line 139 of file CAHitQuadrupletGenerator.h.

Referenced by hitQuadruplets().

const bool CAHitQuadrupletGenerator::fitFastCircle

private

Definition at line 142 of file CAHitQuadrupletGenerator.h.

Referenced by hitQuadruplets().

const bool CAHitQuadrupletGenerator::fitFastCircleChi2Cut

private

Definition at line 143 of file CAHitQuadrupletGenerator.h.

Referenced by hitQuadruplets().

const QuantityDependsPt CAHitQuadrupletGenerator::maxChi2

private

Definition at line 141 of file CAHitQuadrupletGenerator.h.

Referenced by hitQuadruplets().

unsigned int CAHitQuadrupletGenerator::minLayers = 4

static

Definition at line 36 of file CAHitQuadrupletGenerator.h.

std::unique_ptr<SeedComparitor> CAHitQuadrupletGenerator::theComparitor

private

Definition at line 73 of file CAHitQuadrupletGenerator.h.

Referenced by CAHitQuadrupletGenerator(), hitQuadruplets(), and initEvent().

LayerCacheType CAHitQuadrupletGenerator::theLayerCache

private

Definition at line 71 of file CAHitQuadrupletGenerator.h.

Referenced by hitQuadruplets().

edm::EDGetTokenT<SeedingLayerSetsHits> CAHitQuadrupletGenerator::theSeedingLayerToken

private

Definition at line 69 of file CAHitQuadrupletGenerator.h.

Referenced by CAHitQuadrupletGenerator(), and hitQuadruplets().

const bool CAHitQuadrupletGenerator::useBendingCorrection

private

Definition at line 144 of file CAHitQuadrupletGenerator.h.

Referenced by hitQuadruplets().

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation