#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

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 14 of file SeedGeneratorFromProtoTracksEDProducer.h.

Constructor & Destructor Documentation

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

Definition at line 64 of file SeedGeneratorFromProtoTracksEDProducer.cc.

     : 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")),
       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>();
 }

SeedGeneratorFromProtoTracksEDProducer::~SeedGeneratorFromProtoTracksEDProducer ( )

inlineoverride

Definition at line 17 of file SeedGeneratorFromProtoTracksEDProducer.h.

17 {}

Member Function Documentation

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

static

Definition at line 38 of file SeedGeneratorFromProtoTracksEDProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::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);
 
   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);
 }

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 79 of file SeedGeneratorFromProtoTracksEDProducer.cc.

References config_, edm::Event::getByToken(), includeFourthHit_, SeedFromProtoTrack::isValid(), gpuVertexFinder::iv, reco::TrackBase::momentum(), eostools::move(), nHits, SeedingHitSet::nullPtr(), originHalfLength, originRadius, edm::Event::put(), reco::Track::recHit(), reco::Track::recHitsSize(), HLT_FULL_cff::region, mps_fire::result, seedCreator_, sqr(), mathSSE::sqrt(), theInputCollectionTag, theInputVertexCollectionTag, SeedFromProtoTrack::trajectorySeed(), useEventsWithNoVertex, useProtoTrackKinematics, usePV_, reco::TrackBase::vertex(), and beam_dqm_sourceclient-live_cfg::vertices.

                                                                                           {
   auto result = std::make_unique<TrajectorySeedCollection>();
   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 (!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);
         seedCreator_.makeSeed(
             *result,
             SeedingHitSet(hits[0],
                           hits[1],
                           hits.size() > 2 ? hits[2] : SeedingHitSet::nullPtr(),
                           (includeFourthHit_ && hits.size() > 3) ? hits[3] : SeedingHitSet::nullPtr()));
       }
     }
   }
 
   ev.put(std::move(result));
 }