#include <SeedGeneratorFromProtoTracksEDProducer.h>

Inheritance diagram for SeedGeneratorFromProtoTracksEDProducer:

Public Member Functions
void	produce (edm::Event &ev, const edm::EventSetup &es) override

	SeedGeneratorFromProtoTracksEDProducer (const edm::ParameterSet &cfg)

	~SeedGeneratorFromProtoTracksEDProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Attributes
const SeedFromProtoTrack::Config	config_

const bool	includeFourthHit_

const double	originHalfLength

const double	originRadius

const bool	produceComplement_

SeedFromConsecutiveHitsCreator	seedCreator_

const edm::EDGetTokenT< reco::TrackCollection >	theInputCollectionTag

const edm::EDGetTokenT< reco::VertexCollection >	theInputVertexCollectionTag

const bool	useEventsWithNoVertex

const bool	useProtoTrackKinematics

const bool	usePV_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 11 of file SeedGeneratorFromProtoTracksEDProducer.h.

Constructor & Destructor Documentation

◆ SeedGeneratorFromProtoTracksEDProducer()

SeedGeneratorFromProtoTracksEDProducer::SeedGeneratorFromProtoTracksEDProducer ( const edm::ParameterSet & cfg )

Definition at line 64 of file SeedGeneratorFromProtoTracksEDProducer.cc.

References produceComplement_.

     : originHalfLength(cfg.getParameter<double>("originHalfLength")),
       originRadius(cfg.getParameter<double>("originRadius")),
       useProtoTrackKinematics(cfg.getParameter<bool>("useProtoTrackKinematics")),
       useEventsWithNoVertex(cfg.getParameter<bool>("useEventsWithNoVertex")),
       usePV_(cfg.getParameter<bool>("usePV")),
       includeFourthHit_(cfg.getParameter<bool>("includeFourthHit")),
       produceComplement_(cfg.getParameter<bool>("produceComplement")),
       theInputCollectionTag(consumes<reco::TrackCollection>(cfg.getParameter<InputTag>("InputCollection"))),
       theInputVertexCollectionTag(
           consumes<reco::VertexCollection>(cfg.getParameter<InputTag>("InputVertexCollection"))),
       seedCreator_(cfg.getParameter<edm::ParameterSet>("SeedCreatorPSet"), consumesCollector()),
       config_(consumesCollector()) {
   produces<TrajectorySeedCollection>();
   if (produceComplement_) {
     produces<reco::TrackCollection>();
   }
 }

◆ ~SeedGeneratorFromProtoTracksEDProducer()

SeedGeneratorFromProtoTracksEDProducer::~SeedGeneratorFromProtoTracksEDProducer ( )

inlineoverride

Definition at line 14 of file SeedGeneratorFromProtoTracksEDProducer.h.

14 {}

Member Function Documentation

◆ fillDescriptions()

void SeedGeneratorFromProtoTracksEDProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 37 of file SeedGeneratorFromProtoTracksEDProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                         {
   edm::ParameterSetDescription desc;
   desc.add<InputTag>("InputCollection", InputTag("pixelTracks"));
   desc.add<InputTag>("InputVertexCollection", InputTag(""));
   desc.add<double>("originHalfLength", 1E9);
   desc.add<double>("originRadius", 1E9);
   desc.add<bool>("useProtoTrackKinematics", false);
   desc.add<bool>("useEventsWithNoVertex", true);
   desc.add<std::string>("TTRHBuilder", "TTRHBuilderWithoutAngle4PixelTriplets");
   desc.add<bool>("usePV", false);
   desc.add<bool>("includeFourthHit", false);
   desc.add<bool>("produceComplement", false);
 
   edm::ParameterSetDescription psd0;
   psd0.add<std::string>("ComponentName", std::string("SeedFromConsecutiveHitsCreator"));
   psd0.add<std::string>("propagator", std::string("PropagatorWithMaterial"));
   psd0.add<double>("SeedMomentumForBOFF", 5.0);
   psd0.add<double>("OriginTransverseErrorMultiplier", 1.0);
   psd0.add<double>("MinOneOverPtError", 1.0);
   psd0.add<std::string>("magneticField", std::string(""));
   psd0.add<std::string>("TTRHBuilder", std::string("WithTrackAngle"));
   psd0.add<bool>("forceKinematicWithRegionDirection", false);
   desc.add<edm::ParameterSetDescription>("SeedCreatorPSet", psd0);
 
   descriptions.add("SeedGeneratorFromProtoTracksEDProducer", desc);
 }

◆ produce()

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

override

need optimization: all es stuff should go out of the loop

Definition at line 83 of file SeedGeneratorFromProtoTracksEDProducer.cc.

References config_, makeMEIFBenchmarkPlots::ev, hfClusterShapes_cfi::hits, includeFourthHit_, SeedFromProtoTrack::isValid(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::iv, reco::TrackBase::momentum(), eostools::move(), nHits, originHalfLength, originRadius, produceComplement_, reco::Track::recHit(), reco::Track::recHitsSize(), rpcPointValidation_cfi::refHit, nano_mu_digi_cff::region, mps_fire::result, seedCreator_, jetUpdater_cfi::sort, sqr(), mathSSE::sqrt(), theInputCollectionTag, theInputVertexCollectionTag, SeedFromProtoTrack::trajectorySeed(), hltEgammaHLTExtra_cfi::trks, useEventsWithNoVertex, useProtoTrackKinematics, usePV_, reco::TrackBase::vertex(), AlignmentTracksFromVertexSelector_cfi::vertices, and L1BJetProducer_cff::vtx.

                                                                                           {
   auto result = std::make_unique<TrajectorySeedCollection>();
   auto leftTracks = std::make_unique<reco::TrackCollection>();
   Handle<reco::TrackCollection> trks;
   ev.getByToken(theInputCollectionTag, trks);
 
   const TrackCollection& protos = *(trks.product());
 
   edm::Handle<reco::VertexCollection> vertices;
   bool foundVertices = ev.getByToken(theInputVertexCollectionTag, vertices);
   //const reco::VertexCollection & vertices = *(h_vertices.product());
 
   for (TrackCollection::const_iterator it = protos.begin(); it != protos.end(); ++it) {
     const Track& proto = (*it);
     GlobalPoint vtx(proto.vertex().x(), proto.vertex().y(), proto.vertex().z());
 
     // check the compatibility with a primary vertex
     bool keepTrack = false;
     if ((!foundVertices) || vertices->empty()) {
       if (useEventsWithNoVertex)
         keepTrack = true;
     } else if (usePV_) {
       GlobalPoint aPV(
           vertices->begin()->position().x(), vertices->begin()->position().y(), vertices->begin()->position().z());
       double distR2 = sqr(vtx.x() - aPV.x()) + sqr(vtx.y() - aPV.y());
       double distZ = fabs(vtx.z() - aPV.z());
       if (distR2 < sqr(originRadius) && distZ < originHalfLength) {
         keepTrack = true;
       }
     } else {
       for (reco::VertexCollection::const_iterator iv = vertices->begin(); iv != vertices->end(); ++iv) {
         GlobalPoint aPV(iv->position().x(), iv->position().y(), iv->position().z());
         double distR2 = sqr(vtx.x() - aPV.x()) + sqr(vtx.y() - aPV.y());
         double distZ = fabs(vtx.z() - aPV.z());
         if (distR2 < sqr(originRadius) && distZ < originHalfLength) {
           keepTrack = true;
           break;
         }
       }
     }
     if (produceComplement_ and !keepTrack)
       (*leftTracks).push_back(proto);
     if (!keepTrack)
       continue;
 
     if (useProtoTrackKinematics) {
       SeedFromProtoTrack seedFromProtoTrack(config_, proto, es);
       if (seedFromProtoTrack.isValid())
         (*result).push_back(seedFromProtoTrack.trajectorySeed());
     } else {
       std::vector<Hit> hits;
       for (unsigned int iHit = 0, nHits = proto.recHitsSize(); iHit < nHits; ++iHit) {
         TrackingRecHitRef refHit = proto.recHit(iHit);
         if (refHit->isValid())
           hits.push_back((Hit) & (*refHit));
       }
       sort(hits.begin(), hits.end(), HitLessByRadius());
 
       if (hits.size() > 1) {
         double mom_perp =
             sqrt(proto.momentum().x() * proto.momentum().x() + proto.momentum().y() * proto.momentum().y());
         GlobalTrackingRegion region(mom_perp, vtx, 0.2, 0.2);
 
         seedCreator_.init(region, es, nullptr);
         if (hits.size() > 3 and not includeFourthHit_)
           seedCreator_.makeSeed(*result, {hits[0], hits[1], hits[2]});
         else
           seedCreator_.makeSeed(*result, hits);
       }
     }
   }
 
   ev.put(std::move(result));
   if (produceComplement_)
     ev.put(std::move(leftTracks));
 }