CAHitQuadrupletGenerator Class Reference

#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 edm::EventSetup &es, 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 unsigned int	minLayers = 4

Private Attributes
const float	caHardPtCut = 0.f
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
const bool	useBendingCorrection

Detailed Description

Definition at line 29 of file CAHitQuadrupletGenerator.h.

Member Typedef Documentation

typedef LayerHitMapCache CAHitQuadrupletGenerator::LayerCacheType

Definition at line 31 of file CAHitQuadrupletGenerator.h.

typedef OrderedHitSeeds CAHitQuadrupletGenerator::ResultType

Definition at line 34 of file CAHitQuadrupletGenerator.h.

Constructor & Destructor Documentation

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

inline

Definition at line 38 of file CAHitQuadrupletGenerator.h.

References looper::cfg.

: CAHitQuadrupletGenerator(cfg, iC) {}

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

Definition at line 40 of file CAHitQuadrupletGenerator.cc.

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

                                                                                                       :
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"))
{
  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 ( )

default

Member Function Documentation

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

static

Definition at line 58 of file CAHitQuadrupletGenerator.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), 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.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 44 of file CAHitQuadrupletGenerator.h.

References ev, LayerTriplets::layers(), and mps_fire::result.

{ return "caHitQuadruplet"; }

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

Definition at line 182 of file CAHitQuadrupletGenerator.cc.

References funct::abs(), EnergyCorrector::c, caHardPtCut, caPhiCut, caThetaCut, vertices_cff::chi2, FastCircleFit::chi2(), RZLine::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, triggerObjects_cff::id, diffTreeTool::index, PixelRecoUtilities::inversePt(), gedGsfElectrons_cfi::isBarrel, edm::isNotFinite(), maxChi2, TrackingRegion::origin(), PixelSubdetector::PixelBarrel, point, EnergyCorrector::pt, GlobalErrorBase< T, ErrorWeightType >::rerr(), funct::sqr(), mathSSE::sqrt(), theComparitor, 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);
      }
      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(es);

    // 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, 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;
            }
        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 81 of file CAHitQuadrupletGenerator.cc.

References ihd::RegionLayerSets< T >::begin(), ihd::RegionLayerSets< T >::end(), spr::find(), runEdmFileComparison::found, g, hfClusterShapes_cfi::hits, mps_fire::i, LayerTriplets::layers(), dataset::name, SeedingLayerSetsHits::size(), findQualityFiles::size, theComparitor, CAGraph::theLayerPairs, CAGraph::theLayers, CAGraph::theRootLayers, findQualityFiles::v, and egmGedGsfElectronPFIsolation_cff::vertexIndex.

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

Member Data Documentation

const float CAHitQuadrupletGenerator::caHardPtCut = 0.f

private

Definition at line 131 of file CAHitQuadrupletGenerator.h.

Referenced by hitNtuplets().

const float CAHitQuadrupletGenerator::caPhiCut = 0.1f

private

Definition at line 130 of file CAHitQuadrupletGenerator.h.

Referenced by hitNtuplets().

const float CAHitQuadrupletGenerator::caThetaCut = 0.00125f

private

Definition at line 129 of file CAHitQuadrupletGenerator.h.

Referenced by hitNtuplets().

const float CAHitQuadrupletGenerator::extraHitRPhitolerance

private

Definition at line 122 of file CAHitQuadrupletGenerator.h.

Referenced by hitNtuplets().

const bool CAHitQuadrupletGenerator::fitFastCircle

private

Definition at line 125 of file CAHitQuadrupletGenerator.h.

Referenced by hitNtuplets().

const bool CAHitQuadrupletGenerator::fitFastCircleChi2Cut

private

Definition at line 126 of file CAHitQuadrupletGenerator.h.

Referenced by hitNtuplets().

const QuantityDependsPt CAHitQuadrupletGenerator::maxChi2

private

Definition at line 124 of file CAHitQuadrupletGenerator.h.

Referenced by hitNtuplets().

unsigned int CAHitQuadrupletGenerator::minLayers = 4

static

Definition at line 33 of file CAHitQuadrupletGenerator.h.

std::unique_ptr<SeedComparitor> CAHitQuadrupletGenerator::theComparitor

private

Definition at line 56 of file CAHitQuadrupletGenerator.h.

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

LayerCacheType CAHitQuadrupletGenerator::theLayerCache

private

Definition at line 54 of file CAHitQuadrupletGenerator.h.

const bool CAHitQuadrupletGenerator::useBendingCorrection

private

Definition at line 127 of file CAHitQuadrupletGenerator.h.

Referenced by hitNtuplets().