SeedFinderSelector Class Reference

#include <SeedFinderSelector.h>

Public Member Functions
void	initEvent (const edm::Event &, const edm::EventSetup &)
SeedingLayerSetsBuilder::SeedingLayerId	Layer_tuple (const FastTrackerRecHit *hit) const
bool	pass (const std::vector< const FastTrackerRecHit *> &hits) const
	SeedFinderSelector (const edm::ParameterSet &, edm::ConsumesCollector &&)
void	setTrackingRegion (const TrackingRegion *trackingRegion)
	~SeedFinderSelector ()

Private Attributes
std::unique_ptr< CAHitQuadrupletGenerator >	CAHitQuadGenerator_
std::unique_ptr< CAHitTripletGenerator >	CAHitTriplGenerator_
const edm::EventSetup *	eventSetup_
const MagneticField *	field_ = nullptr
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	fieldESToken_
std::vector< unsigned >	layerPairs_
const MeasurementTracker *	measurementTracker_
const edm::ESGetToken< MeasurementTracker, CkfComponentsRecord >	measurementTrackerESToken_
const std::string	measurementTrackerLabel_
const MultipleScatteringParametrisationMaker *	msmaker_ = nullptr
const edm::ESGetToken< MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord >	msMakerESToken_
std::unique_ptr< MultiHitGeneratorFromPairAndLayers >	multiHitGenerator_
std::unique_ptr< HitTripletGeneratorFromPairAndLayers >	pixelTripletGenerator_
std::unique_ptr< SeedingLayerSetsHits >	seedingLayer
std::vector< SeedingLayerSetsBuilder::SeedingLayerId >	seedingLayerIds
std::unique_ptr< SeedingLayerSetsBuilder >	seedingLayers_
const TrackerTopology *	trackerTopology_ = nullptr
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	trackerTopologyESToken_
const TrackingRegion *	trackingRegion_

Detailed Description

Definition at line 29 of file SeedFinderSelector.h.

Constructor & Destructor Documentation

SeedFinderSelector()

SeedFinderSelector::SeedFinderSelector	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	consumesCollector
	)

Definition at line 25 of file SeedFinderSelector.cc.

References CAHitQuadGenerator_, CAHitTriplGenerator_, looper::cfg, Exception, get, edm::ParameterSet::getParameter(), ProducerED_cfi::InputTag, layerPairs_, multiHitGenerator_, pixelTripletGenerator_, seedingLayers_, and AlCaHLTBitMon_QueryRunRegistry::string.

    : trackingRegion_(nullptr),
      eventSetup_(nullptr),
      measurementTracker_(nullptr),
      measurementTrackerLabel_(cfg.getParameter<std::string>("measurementTracker")),
      measurementTrackerESToken_(consumesCollector.esConsumes(edm::ESInputTag("", measurementTrackerLabel_))),
      trackerTopologyESToken_(consumesCollector.esConsumes()),
      fieldESToken_(consumesCollector.esConsumes()),
      msMakerESToken_(consumesCollector.esConsumes()) {
  if (cfg.exists("pixelTripletGeneratorFactory")) {
    const edm::ParameterSet &tripletConfig = cfg.getParameter<edm::ParameterSet>("pixelTripletGeneratorFactory");
    pixelTripletGenerator_ = HitTripletGeneratorFromPairAndLayersFactory::get()->create(
        tripletConfig.getParameter<std::string>("ComponentName"), tripletConfig, consumesCollector);
  }

  if (cfg.exists("MultiHitGeneratorFactory")) {
    const edm::ParameterSet &tripletConfig = cfg.getParameter<edm::ParameterSet>("MultiHitGeneratorFactory");
    multiHitGenerator_ = MultiHitGeneratorFromPairAndLayersFactory::get()->create(
        tripletConfig.getParameter<std::string>("ComponentName"), tripletConfig, consumesCollector);
  }

  if (cfg.exists("CAHitTripletGeneratorFactory")) {
    const edm::ParameterSet &tripletConfig = cfg.getParameter<edm::ParameterSet>("CAHitTripletGeneratorFactory");
    CAHitTriplGenerator_ = std::make_unique<CAHitTripletGenerator>(tripletConfig, consumesCollector);
    seedingLayers_ = std::make_unique<SeedingLayerSetsBuilder>(
        cfg,
        consumesCollector,
        //calling the new FastSim specific constructor to make SeedingLayerSetsHits pointer for triplet iterations
        edm::InputTag("fastTrackerRecHits"));
    layerPairs_ = cfg.getParameter<std::vector<unsigned>>("layerPairs");  //allowed layer pairs for CA triplets
  }

  if (cfg.exists("CAHitQuadrupletGeneratorFactory")) {
    const edm::ParameterSet &quadrupletConfig = cfg.getParameter<edm::ParameterSet>("CAHitQuadrupletGeneratorFactory");
    CAHitQuadGenerator_ = std::make_unique<CAHitQuadrupletGenerator>(quadrupletConfig, consumesCollector);
    //calling the new FastSim specific constructor to make SeedingLayerSetsHits pointer for quadruplet iterations
    seedingLayers_ =
        std::make_unique<SeedingLayerSetsBuilder>(cfg, consumesCollector, edm::InputTag("fastTrackerRecHits"));
    layerPairs_ = cfg.getParameter<std::vector<unsigned>>("layerPairs");  //allowed layer pairs for CA quadruplets
  }

  if ((pixelTripletGenerator_ && multiHitGenerator_) || (CAHitTriplGenerator_ && pixelTripletGenerator_) ||
      (CAHitTriplGenerator_ && multiHitGenerator_)) {
    throw cms::Exception("FastSimTracking")
        << "It is forbidden to specify together 'pixelTripletGeneratorFactory', 'CAHitTripletGeneratorFactory' and "
           "'MultiHitGeneratorFactory' in configuration of SeedFinderSelection";
  }
  if ((pixelTripletGenerator_ && CAHitQuadGenerator_) || (CAHitTriplGenerator_ && CAHitQuadGenerator_) ||
      (multiHitGenerator_ && CAHitQuadGenerator_)) {
    throw cms::Exception("FastSimTracking")
        << "It is forbidden to specify 'CAHitQuadrupletGeneratorFactory' together with 'pixelTripletGeneratorFactory', "
           "'CAHitTripletGeneratorFactory' or 'MultiHitGeneratorFactory' in configuration of SeedFinderSelection";
  }
}

~SeedFinderSelector()

SeedFinderSelector::~SeedFinderSelector

(

)

Definition at line 80 of file SeedFinderSelector.cc.

{ ; }

Member Function Documentation

initEvent()

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

Definition at line 82 of file SeedFinderSelector.cc.

References CAHitQuadGenerator_, CAHitTriplGenerator_, makeMEIFBenchmarkPlots::ev, eventSetup_, field_, fieldESToken_, edm::EventSetup::getData(), measurementTracker_, measurementTrackerESToken_, msmaker_, msMakerESToken_, multiHitGenerator_, seedingLayer, seedingLayerIds, seedingLayers_, trackerTopology_, and trackerTopologyESToken_.

                                                                              {
  eventSetup_ = &es;

  measurementTracker_ = &es.getData(measurementTrackerESToken_);
  trackerTopology_ = &es.getData(trackerTopologyESToken_);
  field_ = &es.getData(fieldESToken_);
  msmaker_ = &es.getData(msMakerESToken_);

  if (multiHitGenerator_) {
    multiHitGenerator_->initES(es);
  }

  //for CA triplet iterations
  if (CAHitTriplGenerator_) {
    seedingLayer = seedingLayers_->makeSeedingLayerSetsHitsforFastSim(ev, es);
    seedingLayerIds = seedingLayers_->layers();
    CAHitTriplGenerator_->initEvent(ev, es);
  }
  //for CA quadruplet iterations
  if (CAHitQuadGenerator_) {
    seedingLayer = seedingLayers_->makeSeedingLayerSetsHitsforFastSim(ev, es);
    seedingLayerIds = seedingLayers_->layers();
    CAHitQuadGenerator_->initEvent(ev, es);
  }
}

Layer_tuple()

SeedingLayerSetsBuilder::SeedingLayerId SeedFinderSelector::Layer_tuple

(

const FastTrackerRecHit *

hit

)

const

Definition at line 326 of file SeedFinderSelector.cc.

References Barrel, GeomDetEnumerators::invalidDet, NegEndcap, GeomDetEnumerators::PixelBarrel, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, GeomDetEnumerators::PixelEndcap, PosEndcap, TrackerTopology::pxbLayer(), TrackerTopology::pxfDisk(), TrackerTopology::pxfSide(), and trackerTopology_.

Referenced by pass().

                                                                                                        {
  GeomDetEnumerators::SubDetector subdet = GeomDetEnumerators::invalidDet;
  TrackerDetSide side = TrackerDetSide::Barrel;
  int idLayer = 0;

  if ((hit->det()->geographicalId()).subdetId() == PixelSubdetector::PixelBarrel) {
    subdet = GeomDetEnumerators::PixelBarrel;
    side = TrackerDetSide::Barrel;
    idLayer = trackerTopology_->pxbLayer(hit->det()->geographicalId());
  } else if ((hit->det()->geographicalId()).subdetId() == PixelSubdetector::PixelEndcap) {
    subdet = GeomDetEnumerators::PixelEndcap;
    idLayer = trackerTopology_->pxfDisk(hit->det()->geographicalId());
    if (trackerTopology_->pxfSide(hit->det()->geographicalId()) == 1) {
      side = TrackerDetSide::NegEndcap;
    } else {
      side = TrackerDetSide::PosEndcap;
    }
  }
  return std::make_tuple(subdet, side, idLayer);
}

pass()

bool SeedFinderSelector::pass

(

const std::vector< const FastTrackerRecHit *> &

hits

)

const

Definition at line 108 of file SeedFinderSelector.cc.

References CAHitQuadGenerator_, CAHitTriplGenerator_, GeometricSearchTracker::detLayer(), HitPairGeneratorFromLayerPair::doublets(), eventSetup_, Exception, field_, trigObjTnPSource_cfi::filler, MeasurementTracker::geometricSearchTracker(), hfClusterShapes_cfi::hits, Layer_tuple(), layerPairs_, hgcalTBTopologyTester_cfi::layers, eostools::ls(), measurementTracker_, eostools::move(), msmaker_, multiHitGenerator_, pixelTracksMonitoring_cff::ntuplet, TrackingRegion::origin(), AlCaHLTBitMon_ParallelJobs::p, pixelTripletGenerator_, mps_fire::result, seedingLayer, seedingLayerIds, and trackingRegion_.

                                                                                    {
  if (!measurementTracker_ || !eventSetup_) {
    throw cms::Exception("FastSimTracking") << "ERROR: event not initialized";
  }
  if (!trackingRegion_) {
    throw cms::Exception("FastSimTracking") << "ERROR: trackingRegion not set";
  }

  // check the inner 2 hits
  if (hits.size() < 2) {
    throw cms::Exception("FastSimTracking") << "SeedFinderSelector::pass requires at least 2 hits";
  }
  const DetLayer *firstLayer =
      measurementTracker_->geometricSearchTracker()->detLayer(hits[0]->det()->geographicalId());
  const DetLayer *secondLayer =
      measurementTracker_->geometricSearchTracker()->detLayer(hits[1]->det()->geographicalId());

  std::vector<BaseTrackerRecHit const *> firstHits{hits[0]};
  std::vector<BaseTrackerRecHit const *> secondHits{hits[1]};

  const RecHitsSortedInPhi fhm(firstHits, trackingRegion_->origin(), firstLayer);
  const RecHitsSortedInPhi shm(secondHits, trackingRegion_->origin(), secondLayer);

  HitDoublets result(fhm, shm);
  HitPairGeneratorFromLayerPair::doublets(
      *trackingRegion_, *firstLayer, *secondLayer, fhm, shm, *field_, *msmaker_, 0, result);

  if (result.empty()) {
    return false;
  }

  // check the inner 3 hits
  if (pixelTripletGenerator_ || multiHitGenerator_ || CAHitTriplGenerator_) {
    if (hits.size() < 3) {
      throw cms::Exception("FastSimTracking")
          << "For the given configuration, SeedFinderSelector::pass requires at least 3 hits";
    }
    const DetLayer *thirdLayer =
        measurementTracker_->geometricSearchTracker()->detLayer(hits[2]->det()->geographicalId());
    std::vector<const DetLayer *> thirdLayerDetLayer(1, thirdLayer);
    std::vector<BaseTrackerRecHit const *> thirdHits{hits[2]};
    const RecHitsSortedInPhi thm(thirdHits, trackingRegion_->origin(), thirdLayer);
    const RecHitsSortedInPhi *thmp = &thm;

    if (pixelTripletGenerator_) {
      OrderedHitTriplets tripletresult;
      pixelTripletGenerator_->hitTriplets(
          *trackingRegion_, tripletresult, *eventSetup_, result, &thmp, thirdLayerDetLayer, 1);
      return !tripletresult.empty();
    } else if (multiHitGenerator_) {
      OrderedMultiHits tripletresult;
      multiHitGenerator_->hitTriplets(*trackingRegion_, tripletresult, result, &thmp, thirdLayerDetLayer, 1);
      return !tripletresult.empty();
    }
    //new for Phase1
    else if (CAHitTriplGenerator_) {
      if (!seedingLayer)
        throw cms::Exception("FastSimTracking") << "ERROR: SeedingLayers pointer not set for CATripletGenerator";

      SeedingLayerSetsHits &layers = *seedingLayer;
      //constructing IntermediateHitDoublets to be passed onto CAHitTripletGenerator::hitNtuplets()
      IntermediateHitDoublets ihd(&layers);
      const TrackingRegion &tr_ = *trackingRegion_;
      auto filler = ihd.beginRegion(&tr_);

      //forming the SeedingLayerId of the hits
      std::array<SeedingLayerSetsBuilder::SeedingLayerId, 3> hitPair;
      hitPair[0] = Layer_tuple(hits[0]);
      hitPair[1] = Layer_tuple(hits[1]);
      hitPair[2] = Layer_tuple(hits[2]);

      //extracting the DetLayer of the hits
      const DetLayer *fLayer =
          measurementTracker_->geometricSearchTracker()->detLayer(hits[0]->det()->geographicalId());
      const DetLayer *sLayer =
          measurementTracker_->geometricSearchTracker()->detLayer(hits[1]->det()->geographicalId());
      const DetLayer *tLayer =
          measurementTracker_->geometricSearchTracker()->detLayer(hits[2]->det()->geographicalId());

      //converting FastTrackerRecHit hits to BaseTrackerRecHit
      std::vector<BaseTrackerRecHit const *> fHits{hits[0]};
      std::vector<BaseTrackerRecHit const *> sHits{hits[1]};
      std::vector<BaseTrackerRecHit const *> tHits{hits[2]};

      //forming the SeedingLayerSet for the hit doublets
      SeedingLayerSetsHits::SeedingLayerSet pairCandidate1, pairCandidate2;
      for (SeedingLayerSetsHits::SeedingLayerSet ls : *seedingLayer) {
        SeedingLayerSetsHits::SeedingLayerSet pairCandidate;
        for (const auto p : layerPairs_) {
          pairCandidate = ls.slice(p, p + 2);
          if (p == 0 && hitPair[0] == seedingLayerIds[pairCandidate[0].index()] &&
              hitPair[1] == seedingLayerIds[pairCandidate[1].index()])
            pairCandidate1 = pairCandidate;
          if (p == 1 && hitPair[1] == seedingLayerIds[pairCandidate[0].index()] &&
              hitPair[2] == seedingLayerIds[pairCandidate[1].index()])
            pairCandidate2 = pairCandidate;
        }
      }

      //Important: hits of the layer to be added to LayerHitMapCache
      auto &layerCache = filler.layerHitMapCache();

      //doublets for CA triplets from the allowed layer pair combinations:(0,1),(1,2) and storing in filler
      const RecHitsSortedInPhi &firsthm = *layerCache.add(
          pairCandidate1[0], std::make_unique<RecHitsSortedInPhi>(fHits, trackingRegion_->origin(), fLayer));
      const RecHitsSortedInPhi &secondhm = *layerCache.add(
          pairCandidate1[1], std::make_unique<RecHitsSortedInPhi>(sHits, trackingRegion_->origin(), sLayer));
      HitDoublets res1(firsthm, secondhm);
      HitPairGeneratorFromLayerPair::doublets(
          *trackingRegion_, *fLayer, *sLayer, firsthm, secondhm, *field_, *msmaker_, 0, res1);
      filler.addDoublets(pairCandidate1, std::move(res1));
      const RecHitsSortedInPhi &thirdhm = *layerCache.add(
          pairCandidate2[1], std::make_unique<RecHitsSortedInPhi>(tHits, trackingRegion_->origin(), tLayer));
      HitDoublets res2(secondhm, thirdhm);
      HitPairGeneratorFromLayerPair::doublets(
          *trackingRegion_, *sLayer, *tLayer, secondhm, thirdhm, *field_, *msmaker_, 0, res2);
      filler.addDoublets(pairCandidate2, std::move(res2));

      std::vector<OrderedHitSeeds> tripletresult;
      tripletresult.resize(ihd.regionSize());
      for (auto &ntuplet : tripletresult)
        ntuplet.reserve(3);
      //calling the function from the class, modifies tripletresult
      CAHitTriplGenerator_->hitNtuplets(ihd, tripletresult, *seedingLayer);
      return !tripletresult[0].empty();
    }
  }
  //new for Phase1
  if (CAHitQuadGenerator_) {
    if (hits.size() < 4) {
      throw cms::Exception("FastSimTracking")
          << "For the given configuration, SeedFinderSelector::pass requires at least 4 hits";
    }

    if (!seedingLayer)
      throw cms::Exception("FastSimTracking") << "ERROR: SeedingLayers pointer not set for CAHitQuadrupletGenerator";

    SeedingLayerSetsHits &layers = *seedingLayer;
    //constructing IntermediateHitDoublets to be passed onto CAHitQuadrupletGenerator::hitNtuplets()
    IntermediateHitDoublets ihd(&layers);
    const TrackingRegion &tr_ = *trackingRegion_;
    auto filler = ihd.beginRegion(&tr_);

    //forming the SeedingLayerId of the hits
    std::array<SeedingLayerSetsBuilder::SeedingLayerId, 4> hitPair;
    hitPair[0] = Layer_tuple(hits[0]);
    hitPair[1] = Layer_tuple(hits[1]);
    hitPair[2] = Layer_tuple(hits[2]);
    hitPair[3] = Layer_tuple(hits[3]);

    //extracting the DetLayer of the hits
    const DetLayer *fLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[0]->det()->geographicalId());
    const DetLayer *sLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[1]->det()->geographicalId());
    const DetLayer *tLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[2]->det()->geographicalId());
    const DetLayer *frLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[3]->det()->geographicalId());

    //converting FastTrackerRecHit hits to BaseTrackerRecHit
    std::vector<BaseTrackerRecHit const *> fHits{hits[0]};
    std::vector<BaseTrackerRecHit const *> sHits{hits[1]};
    std::vector<BaseTrackerRecHit const *> tHits{hits[2]};
    std::vector<BaseTrackerRecHit const *> frHits{hits[3]};

    //forming the SeedingLayerSet for the hit doublets
    SeedingLayerSetsHits::SeedingLayerSet pairCandidate1, pairCandidate2, pairCandidate3;
    for (SeedingLayerSetsHits::SeedingLayerSet ls : *seedingLayer) {
      SeedingLayerSetsHits::SeedingLayerSet pairCandidate;
      for (const auto p : layerPairs_) {
        pairCandidate = ls.slice(p, p + 2);
        if (p == 0 && hitPair[0] == seedingLayerIds[pairCandidate[0].index()] &&
            hitPair[1] == seedingLayerIds[pairCandidate[1].index()])
          pairCandidate1 = pairCandidate;
        if (p == 1 && hitPair[1] == seedingLayerIds[pairCandidate[0].index()] &&
            hitPair[2] == seedingLayerIds[pairCandidate[1].index()])
          pairCandidate2 = pairCandidate;
        if (p == 2 && hitPair[2] == seedingLayerIds[pairCandidate[0].index()] &&
            hitPair[3] == seedingLayerIds[pairCandidate[1].index()])
          pairCandidate3 = pairCandidate;
      }
    }

    //Important: hits of the layer to be added to LayerHitMapCache
    auto &layerCache = filler.layerHitMapCache();

    //doublets for CA quadruplets from the allowed layer pair combinations:(0,1),(1,2),(2,3) and storing in filler
    const RecHitsSortedInPhi &firsthm = *layerCache.add(
        pairCandidate1[0], std::make_unique<RecHitsSortedInPhi>(fHits, trackingRegion_->origin(), fLayer));
    const RecHitsSortedInPhi &secondhm = *layerCache.add(
        pairCandidate1[1], std::make_unique<RecHitsSortedInPhi>(sHits, trackingRegion_->origin(), sLayer));
    HitDoublets res1(firsthm, secondhm);
    HitPairGeneratorFromLayerPair::doublets(
        *trackingRegion_, *fLayer, *sLayer, firsthm, secondhm, *field_, *msmaker_, 0, res1);
    filler.addDoublets(pairCandidate1, std::move(res1));
    const RecHitsSortedInPhi &thirdhm = *layerCache.add(
        pairCandidate2[1], std::make_unique<RecHitsSortedInPhi>(tHits, trackingRegion_->origin(), tLayer));
    HitDoublets res2(secondhm, thirdhm);
    HitPairGeneratorFromLayerPair::doublets(
        *trackingRegion_, *sLayer, *tLayer, secondhm, thirdhm, *field_, *msmaker_, 0, res2);
    filler.addDoublets(pairCandidate2, std::move(res2));
    const RecHitsSortedInPhi &fourthhm = *layerCache.add(
        pairCandidate3[1], std::make_unique<RecHitsSortedInPhi>(frHits, trackingRegion_->origin(), frLayer));
    HitDoublets res3(thirdhm, fourthhm);
    HitPairGeneratorFromLayerPair::doublets(
        *trackingRegion_, *tLayer, *frLayer, thirdhm, fourthhm, *field_, *msmaker_, 0, res3);
    filler.addDoublets(pairCandidate3, std::move(res3));

    std::vector<OrderedHitSeeds> quadrupletresult;
    quadrupletresult.resize(ihd.regionSize());
    for (auto &ntuplet : quadrupletresult)
      ntuplet.reserve(4);
    //calling the function from the class, modifies quadrupletresult
    CAHitQuadGenerator_->hitNtuplets(ihd, quadrupletresult, *seedingLayer);
    return !quadrupletresult[0].empty();
  }

  return true;
}

setTrackingRegion()

void SeedFinderSelector::setTrackingRegion ( const TrackingRegion *  trackingRegion )

inline

Definition at line 37 of file SeedFinderSelector.h.

References trackingRegion_.

{ trackingRegion_ = trackingRegion; }

Member Data Documentation

CAHitQuadGenerator_

std::unique_ptr<CAHitQuadrupletGenerator> SeedFinderSelector::CAHitQuadGenerator_

private

Definition at line 58 of file SeedFinderSelector.h.

Referenced by initEvent(), pass(), and SeedFinderSelector().

CAHitTriplGenerator_

std::unique_ptr<CAHitTripletGenerator> SeedFinderSelector::CAHitTriplGenerator_

private

Definition at line 57 of file SeedFinderSelector.h.

Referenced by initEvent(), pass(), and SeedFinderSelector().

eventSetup_

const edm::EventSetup* SeedFinderSelector::eventSetup_

private

Definition at line 47 of file SeedFinderSelector.h.

Referenced by initEvent(), and pass().

field_

const MagneticField* SeedFinderSelector::field_ = nullptr

private

Definition at line 55 of file SeedFinderSelector.h.

Referenced by initEvent(), and pass().

fieldESToken_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> SeedFinderSelector::fieldESToken_

private

Definition at line 52 of file SeedFinderSelector.h.

Referenced by initEvent().

layerPairs_

std::vector<unsigned> SeedFinderSelector::layerPairs_

private

Definition at line 61 of file SeedFinderSelector.h.

Referenced by pass(), and SeedFinderSelector().

measurementTracker_

const MeasurementTracker* SeedFinderSelector::measurementTracker_

private

Definition at line 48 of file SeedFinderSelector.h.

Referenced by initEvent(), and pass().

measurementTrackerESToken_

const edm::ESGetToken<MeasurementTracker, CkfComponentsRecord> SeedFinderSelector::measurementTrackerESToken_

private

Definition at line 50 of file SeedFinderSelector.h.

Referenced by initEvent().

measurementTrackerLabel_

const std::string SeedFinderSelector::measurementTrackerLabel_

private

Definition at line 49 of file SeedFinderSelector.h.

msmaker_

const MultipleScatteringParametrisationMaker* SeedFinderSelector::msmaker_ = nullptr

private

Definition at line 56 of file SeedFinderSelector.h.

Referenced by initEvent(), and pass().

msMakerESToken_

const edm::ESGetToken<MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord> SeedFinderSelector::msMakerESToken_

private

Definition at line 53 of file SeedFinderSelector.h.

Referenced by initEvent().

multiHitGenerator_

std::unique_ptr<MultiHitGeneratorFromPairAndLayers> SeedFinderSelector::multiHitGenerator_

private

Definition at line 45 of file SeedFinderSelector.h.

Referenced by initEvent(), pass(), and SeedFinderSelector().

pixelTripletGenerator_

std::unique_ptr<HitTripletGeneratorFromPairAndLayers> SeedFinderSelector::pixelTripletGenerator_

private

Definition at line 44 of file SeedFinderSelector.h.

Referenced by pass(), and SeedFinderSelector().

seedingLayer

std::unique_ptr<SeedingLayerSetsHits> SeedFinderSelector::seedingLayer

private

Definition at line 60 of file SeedFinderSelector.h.

Referenced by initEvent(), and pass().

seedingLayerIds

std::vector<SeedingLayerSetsBuilder::SeedingLayerId> SeedFinderSelector::seedingLayerIds

private

Definition at line 62 of file SeedFinderSelector.h.

Referenced by initEvent(), and pass().

seedingLayers_

std::unique_ptr<SeedingLayerSetsBuilder> SeedFinderSelector::seedingLayers_

private

Definition at line 59 of file SeedFinderSelector.h.

Referenced by initEvent(), and SeedFinderSelector().

trackerTopology_

const TrackerTopology* SeedFinderSelector::trackerTopology_ = nullptr

private

Definition at line 54 of file SeedFinderSelector.h.

Referenced by initEvent(), and Layer_tuple().

trackerTopologyESToken_

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> SeedFinderSelector::trackerTopologyESToken_

private

Definition at line 51 of file SeedFinderSelector.h.

Referenced by initEvent().

trackingRegion_

const TrackingRegion* SeedFinderSelector::trackingRegion_

private

Definition at line 46 of file SeedFinderSelector.h.

Referenced by pass(), and setTrackingRegion().