#include <CAHitQuadrupletGenerator.h>

Classes
class	QuantityDependsPt

class	QuantityDependsPtEval

Public Types
typedef LayerHitMapCache	LayerCacheType

typedef OrderedHitSeeds	ResultType

Public Member Functions
	CAHitQuadrupletGenerator (const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC)

	CAHitQuadrupletGenerator (const edm::ParameterSet &cfg, edm::ConsumesCollector &iC)

void	hitNtuplets (const IntermediateHitDoublets &regionDoublets, std::vector< OrderedHitSeeds > &result, const SeedingLayerSetsHits &layers)

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

	~CAHitQuadrupletGenerator ()=default

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

static const char *	fillDescriptionsLabel ()

Static Public Attributes
static constexpr unsigned int	minLayers = 4

Private Attributes
const float	caHardPtCut = 0.f

CACut	caPhiCut

CACut	caThetaCut

const float	extraHitRPhitolerance

const bool	fitFastCircle

const bool	fitFastCircleChi2Cut

const QuantityDependsPt	maxChi2

std::unique_ptr< SeedComparitor >	theComparitor

const MagneticField *	theField = nullptr

const edm::ESGetToken < MagneticField, IdealMagneticFieldRecord >	theFieldToken

LayerCacheType	theLayerCache

const bool	useBendingCorrection

Detailed Description

Definition at line 31 of file CAHitQuadrupletGenerator.h.

Member Typedef Documentation

typedef LayerHitMapCache CAHitQuadrupletGenerator::LayerCacheType

Definition at line 33 of file CAHitQuadrupletGenerator.h.

typedef OrderedHitSeeds CAHitQuadrupletGenerator::ResultType

Definition at line 36 of file CAHitQuadrupletGenerator.h.

Constructor & Destructor Documentation

CAHitQuadrupletGenerator::CAHitQuadrupletGenerator	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	iC
	)

inline

Definition at line 39 of file CAHitQuadrupletGenerator.h.

40 : CAHitQuadrupletGenerator(cfg, iC) {}

CAHitQuadrupletGenerator::CAHitQuadrupletGenerator

CAHitQuadrupletGenerator(const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC)

Definition: CAHitQuadrupletGenerator.h:39

CAHitQuadrupletGenerator::CAHitQuadrupletGenerator	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &	iC
	)

Definition at line 27 of file CAHitQuadrupletGenerator.cc.

References get, edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, and theComparitor.

     : theFieldToken(iC.esConsumes()),
       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"),
                  cfg.getParameter<std::vector<edm::ParameterSet>>("CAThetaCut_byTriplets")),
       caPhiCut(cfg.getParameter<double>("CAPhiCut"),
                cfg.getParameter<std::vector<edm::ParameterSet>>("CAPhiCut_byTriplets")),
       caHardPtCut(cfg.getParameter<double>("CAHardPtCut")) {
   edm::ParameterSet comparitorPSet = cfg.getParameter<edm::ParameterSet>("SeedComparitorPSet");
   std::string comparitorName = comparitorPSet.getParameter<std::string>("ComponentName");
   if (comparitorName != "none") {
     theComparitor = SeedComparitorFactory::get()->create(comparitorName, comparitorPSet, iC);
   }
 }

CAHitQuadrupletGenerator::~CAHitQuadrupletGenerator ( )

default

Member Function Documentation

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

static

Definition at line 47 of file CAHitQuadrupletGenerator.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), 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);
 
   edm::ParameterSetDescription validatorCACut;
   validatorCACut.add<string>("seedingLayers", "BPix1+BPix2+BPix3");
   validatorCACut.add<double>("cut", 0.00125);
   std::vector<edm::ParameterSet> defaultCACutVector;
   edm::ParameterSet defaultCACut;
   defaultCACut.addParameter<string>("seedingLayers", "");
   defaultCACut.addParameter<double>("cut", -1.);
   defaultCACutVector.push_back(defaultCACut);
   desc.addVPSet("CAThetaCut_byTriplets", validatorCACut, defaultCACutVector);
   desc.addVPSet("CAPhiCut_byTriplets", validatorCACut, defaultCACutVector);
 
   desc.add<double>("CAHardPtCut", 0);
   desc.addOptional<bool>("CAOnlyOneLastHitPerLayerFilter")
       ->setComment(
           "Deprecated and has no effect. To be fully removed later when the parameter is no longer used in HLT "
           "configurations.");
   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 46 of file CAHitQuadrupletGenerator.h.

46 { return "caHitQuadrupletDefault"; }

void CAHitQuadrupletGenerator::hitNtuplets	(	const IntermediateHitDoublets &	regionDoublets,
		std::vector< OrderedHitSeeds > &	result,
		const SeedingLayerSetsHits &	layers
	)

Definition at line 162 of file CAHitQuadrupletGenerator.cc.

References funct::abs(), c, caHardPtCut, caPhiCut, caThetaCut, FastCircleFit::chi2(), RZLine::chi2(), HLT_FULL_cff::chi2, CellularAutomaton::createAndConnectCells(), PixelRecoUtilities::curvature(), GlobalErrorBase< T, ErrorWeightType >::czz(), relativeConstraints::error, CAHitQuadrupletGenerator::QuantityDependsPt::evaluator(), CellularAutomaton::evolve(), extraHitRPhitolerance, CellularAutomaton::findNtuplets(), fitFastCircle, fitFastCircleChi2Cut, g, CellularAutomaton::getAllCells(), mps_fire::i, gpuClustering::id, PixelRecoUtilities::inversePt(), PixelPluginsPhase0_cfi::isBarrel, edm::isNotFinite(), maxChi2, TrackingRegion::origin(), PixelSubdetector::PixelBarrel, point, DiDispStaMuonMonitor_cfi::pt, ihd::RegionLayerSets< T >::region(), HLT_FULL_cff::region, GlobalErrorBase< T, ErrorWeightType >::rerr(), CACut::setCutValuesByLayerIds(), sqr(), mathSSE::sqrt(), theComparitor, theField, useBendingCorrection, CAHitQuadrupletGenerator::QuantityDependsPtEval::value(), x, PV3DBase< T, PVType, FrameType >::x(), y, PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                {
   CAGraph g;
 
   std::vector<const HitDoublets*> hitDoublets;
 
   const int numberOfHitsInNtuplet = 4;
   std::vector<CACell::CAntuplet> foundQuadruplets;
 
   int index = 0;
   for (const auto& regionLayerPairs : regionDoublets) {
     const TrackingRegion& region = regionLayerPairs.region();
     hitDoublets.clear();
     foundQuadruplets.clear();
     if (index == 0) {
       createGraphStructure(layers, g);
       caThetaCut.setCutValuesByLayerIds(g);
       caPhiCut.setCutValuesByLayerIds(g);
     } else {
       clearGraphStructure(layers, g);
     }
 
     fillGraph(layers, regionLayerPairs, g, hitDoublets);
 
     CellularAutomaton ca(g);
 
     ca.createAndConnectCells(hitDoublets, region, caThetaCut, caPhiCut, caHardPtCut);
 
     ca.evolve(numberOfHitsInNtuplet);
 
     ca.findNtuplets(foundQuadruplets, numberOfHitsInNtuplet);
 
     auto& allCells = ca.getAllCells();
 
     const QuantityDependsPtEval maxChi2Eval = maxChi2.evaluator(*theField);
 
     // re-used thoughout
     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 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 = allCells[foundQuadruplets[quadId][i]].getInnerHit();
         gps[i] = ahit->globalPosition();
         ges[i] = ahit->globalPositionError();
         barrels[i] = isBarrel(ahit->geographicalId().subdetId());
       }
 
       auto const& ahit = allCells[foundQuadruplets[quadId][2]].getOuterHit();
       gps[3] = ahit->globalPosition();
       ges[3] = ahit->globalPositionError();
       barrels[3] = isBarrel(ahit->geographicalId().subdetId());
       // TODO:
       // - 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
       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(allCells[foundQuadruplets[quadId][0]].getInnerHit(),
                                  allCells[foundQuadruplets[quadId][2]].getInnerHit(),
                                  allCells[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, *theField);
         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, *theField)(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;
       }
       result[index].emplace_back(allCells[foundQuadruplets[quadId][0]].getInnerHit(),
                                  allCells[foundQuadruplets[quadId][1]].getInnerHit(),
                                  allCells[foundQuadruplets[quadId][2]].getInnerHit(),
                                  allCells[foundQuadruplets[quadId][2]].getOuterHit());
     }
     index++;
   }
 }

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

Definition at line 85 of file CAHitQuadrupletGenerator.cc.

References edm::EventSetup::getData(), theComparitor, theField, and theFieldToken.

                                                                                     {
   if (theComparitor)
     theComparitor->init(ev, es);
   theField = &es.getData(theFieldToken);
 }